Coverage Report

Created: 2026-02-09 03:50

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/__w/smoldot/smoldot/repo/target/debug/build/cranelift-codegen-cadc23fc31cc46c7/out/isle_opt.rs
Line
Count
Source
1
// GENERATED BY ISLE. DO NOT EDIT!
2
//
3
// Generated automatically from the instruction-selection DSL code in:
4
// - src/prelude.isle
5
// - src/prelude_opt.isle
6
// - src/opts/arithmetic.isle
7
// - src/opts/bitops.isle
8
// - src/opts/cprop.isle
9
// - src/opts/extends.isle
10
// - src/opts/icmp.isle
11
// - src/opts/remat.isle
12
// - src/opts/selects.isle
13
// - src/opts/shifts.isle
14
// - src/opts/skeleton.isle
15
// - src/opts/spaceship.isle
16
// - src/opts/spectre.isle
17
// - src/opts/vector.isle
18
// - <OUT_DIR>/numerics.isle
19
// - <OUT_DIR>/clif_opt.isle
20
21
use super::*;  // Pulls in all external types.
22
use std::marker::PhantomData;
23
24
/// Context during lowering: an implementation of this trait
25
/// must be provided with all external constructors and extractors.
26
/// A mutable borrow is passed along through all lowering logic.
27
pub trait Context {
28
    fn unit(&mut self, ) -> Unit;
29
    fn def_inst(&mut self, arg0: Value) -> Option<Inst>;
30
    fn value_type(&mut self, arg0: Value) -> Type;
31
    fn u32_nonnegative(&mut self, arg0: u32) -> Option<u32>;
32
    fn offset32(&mut self, arg0: Offset32) -> i32;
33
    fn checked_add_with_type(&mut self, arg0: Type, arg1: u64, arg2: u64) -> Option<u64>;
34
    fn add_overflows_with_type(&mut self, arg0: Type, arg1: u64, arg2: u64) -> bool;
35
    fn imm64_sdiv(&mut self, arg0: Type, arg1: Imm64, arg2: Imm64) -> Option<Imm64>;
36
    fn imm64_shl(&mut self, arg0: Type, arg1: Imm64, arg2: Imm64) -> Imm64;
37
    fn imm64_ushr(&mut self, arg0: Type, arg1: Imm64, arg2: Imm64) -> Imm64;
38
    fn imm64_sshr(&mut self, arg0: Type, arg1: Imm64, arg2: Imm64) -> Imm64;
39
    fn i64_sextend_u64(&mut self, arg0: Type, arg1: u64) -> i64;
40
    fn i64_sextend_imm64(&mut self, arg0: Type, arg1: Imm64) -> i64;
41
    fn u64_uextend_imm64(&mut self, arg0: Type, arg1: Imm64) -> u64;
42
    fn imm64_icmp(&mut self, arg0: Type, arg1: &IntCC, arg2: Imm64, arg3: Imm64) -> Imm64;
43
    fn u128_replicated_u64(&mut self, arg0: u128) -> Option<u64>;
44
    fn u64_replicated_u32(&mut self, arg0: u64) -> Option<u64>;
45
    fn u32_replicated_u16(&mut self, arg0: u64) -> Option<u64>;
46
    fn u16_replicated_u8(&mut self, arg0: u64) -> Option<u8>;
47
    fn u128_low_bits(&mut self, arg0: u128) -> u64;
48
    fn u128_high_bits(&mut self, arg0: u128) -> u64;
49
    fn f16_min(&mut self, arg0: Ieee16, arg1: Ieee16) -> Option<Ieee16>;
50
    fn f16_max(&mut self, arg0: Ieee16, arg1: Ieee16) -> Option<Ieee16>;
51
    fn f16_neg(&mut self, arg0: Ieee16) -> Ieee16;
52
    fn f16_abs(&mut self, arg0: Ieee16) -> Ieee16;
53
    fn f16_copysign(&mut self, arg0: Ieee16, arg1: Ieee16) -> Ieee16;
54
    fn f32_add(&mut self, arg0: Ieee32, arg1: Ieee32) -> Option<Ieee32>;
55
    fn f32_sub(&mut self, arg0: Ieee32, arg1: Ieee32) -> Option<Ieee32>;
56
    fn f32_mul(&mut self, arg0: Ieee32, arg1: Ieee32) -> Option<Ieee32>;
57
    fn f32_div(&mut self, arg0: Ieee32, arg1: Ieee32) -> Option<Ieee32>;
58
    fn f32_sqrt(&mut self, arg0: Ieee32) -> Option<Ieee32>;
59
    fn f32_ceil(&mut self, arg0: Ieee32) -> Option<Ieee32>;
60
    fn f32_floor(&mut self, arg0: Ieee32) -> Option<Ieee32>;
61
    fn f32_trunc(&mut self, arg0: Ieee32) -> Option<Ieee32>;
62
    fn f32_nearest(&mut self, arg0: Ieee32) -> Option<Ieee32>;
63
    fn f32_min(&mut self, arg0: Ieee32, arg1: Ieee32) -> Option<Ieee32>;
64
    fn f32_max(&mut self, arg0: Ieee32, arg1: Ieee32) -> Option<Ieee32>;
65
    fn f32_neg(&mut self, arg0: Ieee32) -> Ieee32;
66
    fn f32_abs(&mut self, arg0: Ieee32) -> Ieee32;
67
    fn f32_copysign(&mut self, arg0: Ieee32, arg1: Ieee32) -> Ieee32;
68
    fn f64_add(&mut self, arg0: Ieee64, arg1: Ieee64) -> Option<Ieee64>;
69
    fn f64_sub(&mut self, arg0: Ieee64, arg1: Ieee64) -> Option<Ieee64>;
70
    fn f64_mul(&mut self, arg0: Ieee64, arg1: Ieee64) -> Option<Ieee64>;
71
    fn f64_div(&mut self, arg0: Ieee64, arg1: Ieee64) -> Option<Ieee64>;
72
    fn f64_sqrt(&mut self, arg0: Ieee64) -> Option<Ieee64>;
73
    fn f64_ceil(&mut self, arg0: Ieee64) -> Option<Ieee64>;
74
    fn f64_floor(&mut self, arg0: Ieee64) -> Option<Ieee64>;
75
    fn f64_trunc(&mut self, arg0: Ieee64) -> Option<Ieee64>;
76
    fn f64_nearest(&mut self, arg0: Ieee64) -> Option<Ieee64>;
77
    fn f64_min(&mut self, arg0: Ieee64, arg1: Ieee64) -> Option<Ieee64>;
78
    fn f64_max(&mut self, arg0: Ieee64, arg1: Ieee64) -> Option<Ieee64>;
79
    fn f64_neg(&mut self, arg0: Ieee64) -> Ieee64;
80
    fn f64_abs(&mut self, arg0: Ieee64) -> Ieee64;
81
    fn f64_copysign(&mut self, arg0: Ieee64, arg1: Ieee64) -> Ieee64;
82
    fn f128_min(&mut self, arg0: Ieee128, arg1: Ieee128) -> Option<Ieee128>;
83
    fn f128_max(&mut self, arg0: Ieee128, arg1: Ieee128) -> Option<Ieee128>;
84
    fn f128_neg(&mut self, arg0: Ieee128) -> Ieee128;
85
    fn f128_abs(&mut self, arg0: Ieee128) -> Ieee128;
86
    fn f128_copysign(&mut self, arg0: Ieee128, arg1: Ieee128) -> Ieee128;
87
    fn ty_umin(&mut self, arg0: Type) -> u64;
88
    fn ty_umax(&mut self, arg0: Type) -> u64;
89
    fn ty_smin(&mut self, arg0: Type) -> u64;
90
    fn ty_smax(&mut self, arg0: Type) -> u64;
91
    fn ty_bits(&mut self, arg0: Type) -> u8;
92
    fn ty_bits_u16(&mut self, arg0: Type) -> u16;
93
    fn ty_bits_u64(&mut self, arg0: Type) -> u64;
94
    fn ty_mask(&mut self, arg0: Type) -> u64;
95
    fn ty_lane_mask(&mut self, arg0: Type) -> u64;
96
    fn ty_lane_count(&mut self, arg0: Type) -> u64;
97
    fn ty_bytes(&mut self, arg0: Type) -> u16;
98
    fn lane_type(&mut self, arg0: Type) -> Type;
99
    fn ty_half_lanes(&mut self, arg0: Type) -> Option<Type>;
100
    fn ty_half_width(&mut self, arg0: Type) -> Option<Type>;
101
    fn ty_equal(&mut self, arg0: Type, arg1: Type) -> bool;
102
    fn mem_flags_trusted(&mut self, ) -> MemFlags;
103
    fn little_or_native_endian(&mut self, arg0: MemFlags) -> Option<MemFlags>;
104
    fn intcc_swap_args(&mut self, arg0: &IntCC) -> IntCC;
105
    fn intcc_complement(&mut self, arg0: &IntCC) -> IntCC;
106
    fn intcc_without_eq(&mut self, arg0: &IntCC) -> IntCC;
107
    fn floatcc_swap_args(&mut self, arg0: &FloatCC) -> FloatCC;
108
    fn floatcc_complement(&mut self, arg0: &FloatCC) -> FloatCC;
109
    fn floatcc_unordered(&mut self, arg0: &FloatCC) -> bool;
110
    fn fits_in_16(&mut self, arg0: Type) -> Option<Type>;
111
    fn fits_in_32(&mut self, arg0: Type) -> Option<Type>;
112
    fn lane_fits_in_32(&mut self, arg0: Type) -> Option<Type>;
113
    fn fits_in_64(&mut self, arg0: Type) -> Option<Type>;
114
    fn ty_16(&mut self, arg0: Type) -> Option<Type>;
115
    fn ty_32(&mut self, arg0: Type) -> Option<Type>;
116
    fn ty_64(&mut self, arg0: Type) -> Option<Type>;
117
    fn ty_128(&mut self, arg0: Type) -> Option<Type>;
118
    fn ty_int_ref_scalar_64_extract(&mut self, arg0: Type) -> Option<Type>;
119
    fn ty_int_ref_scalar_64(&mut self, arg0: Type) -> Option<Type>;
120
    fn ty_32_or_64(&mut self, arg0: Type) -> Option<Type>;
121
    fn ty_8_or_16(&mut self, arg0: Type) -> Option<Type>;
122
    fn ty_16_or_32(&mut self, arg0: Type) -> Option<Type>;
123
    fn int_fits_in_32(&mut self, arg0: Type) -> Option<Type>;
124
    fn ty_int_ref_64(&mut self, arg0: Type) -> Option<Type>;
125
    fn ty_int_ref_16_to_64(&mut self, arg0: Type) -> Option<Type>;
126
    fn ty_int(&mut self, arg0: Type) -> Option<Type>;
127
    fn ty_scalar(&mut self, arg0: Type) -> Option<Type>;
128
    fn ty_scalar_float(&mut self, arg0: Type) -> Option<Type>;
129
    fn ty_float_or_vec(&mut self, arg0: Type) -> Option<Type>;
130
    fn ty_vector_float(&mut self, arg0: Type) -> Option<Type>;
131
    fn ty_vector_not_float(&mut self, arg0: Type) -> Option<Type>;
132
    fn ty_vec64(&mut self, arg0: Type) -> Option<Type>;
133
    fn ty_vec64_ctor(&mut self, arg0: Type) -> Option<Type>;
134
    fn ty_vec128(&mut self, arg0: Type) -> Option<Type>;
135
    fn ty_dyn_vec64(&mut self, arg0: Type) -> Option<Type>;
136
    fn ty_dyn_vec128(&mut self, arg0: Type) -> Option<Type>;
137
    fn ty_vec64_int(&mut self, arg0: Type) -> Option<Type>;
138
    fn ty_vec128_int(&mut self, arg0: Type) -> Option<Type>;
139
    fn ty_addr64(&mut self, arg0: Type) -> Option<Type>;
140
    fn not_vec32x2(&mut self, arg0: Type) -> Option<Type>;
141
    fn not_i64x2(&mut self, arg0: Type) -> Option<()>;
142
    fn u8_from_uimm8(&mut self, arg0: Uimm8) -> u8;
143
    fn u64_from_bool(&mut self, arg0: bool) -> u64;
144
    fn u64_from_imm64(&mut self, arg0: Imm64) -> u64;
145
    fn nonzero_u64_from_imm64(&mut self, arg0: Imm64) -> Option<u64>;
146
    fn imm64_power_of_two(&mut self, arg0: Imm64) -> Option<u64>;
147
    fn imm64(&mut self, arg0: u64) -> Imm64;
148
    fn imm64_masked(&mut self, arg0: Type, arg1: u64) -> Imm64;
149
    fn u16_from_ieee16(&mut self, arg0: Ieee16) -> u16;
150
    fn u32_from_ieee32(&mut self, arg0: Ieee32) -> u32;
151
    fn u64_from_ieee64(&mut self, arg0: Ieee64) -> u64;
152
    fn multi_lane(&mut self, arg0: Type) -> Option<(u32, u32)>;
153
    fn dynamic_lane(&mut self, arg0: Type) -> Option<(u32, u32)>;
154
    fn ty_dyn64_int(&mut self, arg0: Type) -> Option<Type>;
155
    fn ty_dyn128_int(&mut self, arg0: Type) -> Option<Type>;
156
    fn offset32_to_i32(&mut self, arg0: Offset32) -> i32;
157
    fn i32_to_offset32(&mut self, arg0: i32) -> Offset32;
158
    fn intcc_unsigned(&mut self, arg0: &IntCC) -> IntCC;
159
    fn signed_cond_code(&mut self, arg0: &IntCC) -> Option<IntCC>;
160
    fn trap_code_division_by_zero(&mut self, ) -> TrapCode;
161
    fn trap_code_integer_overflow(&mut self, ) -> TrapCode;
162
    fn trap_code_bad_conversion_to_integer(&mut self, ) -> TrapCode;
163
    type inst_data_value_etor_returns: Default + IntoContextIter<Context = Self, Output = (Type, InstructionData)>;
164
    fn inst_data_value_etor(&mut self, arg0: Value, returns: &mut Self::inst_data_value_etor_returns) -> ();
165
    fn inst_data_etor(&mut self, arg0: Inst) -> Option<InstructionData>;
166
    type inst_data_value_tupled_etor_returns: Default + IntoContextIter<Context = Self, Output = TypeAndInstructionData>;
167
    fn inst_data_value_tupled_etor(&mut self, arg0: Value, returns: &mut Self::inst_data_value_tupled_etor_returns) -> ();
168
    fn make_inst_ctor(&mut self, arg0: Type, arg1: &InstructionData) -> Value;
169
    fn make_skeleton_inst_ctor(&mut self, arg0: &InstructionData) -> Inst;
170
    fn value_array_2_ctor(&mut self, arg0: Value, arg1: Value) -> ValueArray2;
171
    fn value_array_3_ctor(&mut self, arg0: Value, arg1: Value, arg2: Value) -> ValueArray3;
172
    fn remat(&mut self, arg0: Value) -> Value;
173
    fn subsume(&mut self, arg0: Value) -> Value;
174
    fn iconst_sextend_etor(&mut self, arg0: TypeAndInstructionData) -> Option<(Type, i64)>;
175
    type sextend_maybe_etor_returns: Default + IntoContextIter<Context = Self, Output = (Type, Value)>;
176
    fn sextend_maybe_etor(&mut self, arg0: Value, returns: &mut Self::sextend_maybe_etor_returns) -> ();
177
    type uextend_maybe_etor_returns: Default + IntoContextIter<Context = Self, Output = (Type, Value)>;
178
    fn uextend_maybe_etor(&mut self, arg0: Value, returns: &mut Self::uextend_maybe_etor_returns) -> ();
179
    fn div_const_magic_u32(&mut self, arg0: u32) -> DivConstMagicU32;
180
    fn div_const_magic_u64(&mut self, arg0: u64) -> DivConstMagicU64;
181
    fn div_const_magic_s32(&mut self, arg0: i32) -> DivConstMagicS32;
182
    fn div_const_magic_s64(&mut self, arg0: i64) -> DivConstMagicS64;
183
    fn splat64(&mut self, arg0: u64) -> Constant;
184
    fn f32_from_uint(&mut self, arg0: u64) -> Ieee32;
185
    fn f64_from_uint(&mut self, arg0: u64) -> Ieee64;
186
    fn f32_from_sint(&mut self, arg0: i64) -> Ieee32;
187
    fn f64_from_sint(&mut self, arg0: i64) -> Ieee64;
188
    fn u64_bswap16(&mut self, arg0: u64) -> u64;
189
    fn u64_bswap32(&mut self, arg0: u64) -> u64;
190
    fn u64_bswap64(&mut self, arg0: u64) -> u64;
191
    fn ieee128_constant_extractor(&mut self, arg0: Constant) -> Option<Ieee128>;
192
    fn ieee128_constant(&mut self, arg0: Ieee128) -> Constant;
193
    fn i8_eq(&mut self, arg0: i8, arg1: i8) -> bool;
194
    fn i8_ne(&mut self, arg0: i8, arg1: i8) -> bool;
195
    fn i8_lt(&mut self, arg0: i8, arg1: i8) -> bool;
196
    fn i8_lt_eq(&mut self, arg0: i8, arg1: i8) -> bool;
197
    fn i8_gt(&mut self, arg0: i8, arg1: i8) -> bool;
198
    fn i8_gt_eq(&mut self, arg0: i8, arg1: i8) -> bool;
199
    fn i8_checked_add(&mut self, arg0: i8, arg1: i8) -> Option<i8>;
200
    fn i8_wrapping_add(&mut self, arg0: i8, arg1: i8) -> i8;
201
    fn i8_add(&mut self, arg0: i8, arg1: i8) -> i8;
202
    fn i8_checked_sub(&mut self, arg0: i8, arg1: i8) -> Option<i8>;
203
    fn i8_wrapping_sub(&mut self, arg0: i8, arg1: i8) -> i8;
204
    fn i8_sub(&mut self, arg0: i8, arg1: i8) -> i8;
205
    fn i8_checked_mul(&mut self, arg0: i8, arg1: i8) -> Option<i8>;
206
    fn i8_wrapping_mul(&mut self, arg0: i8, arg1: i8) -> i8;
207
    fn i8_mul(&mut self, arg0: i8, arg1: i8) -> i8;
208
    fn i8_checked_div(&mut self, arg0: i8, arg1: i8) -> Option<i8>;
209
    fn i8_wrapping_div(&mut self, arg0: i8, arg1: i8) -> i8;
210
    fn i8_div(&mut self, arg0: i8, arg1: i8) -> i8;
211
    fn i8_checked_rem(&mut self, arg0: i8, arg1: i8) -> Option<i8>;
212
    fn i8_rem(&mut self, arg0: i8, arg1: i8) -> i8;
213
    fn i8_and(&mut self, arg0: i8, arg1: i8) -> i8;
214
    fn i8_or(&mut self, arg0: i8, arg1: i8) -> i8;
215
    fn i8_xor(&mut self, arg0: i8, arg1: i8) -> i8;
216
    fn i8_not(&mut self, arg0: i8) -> i8;
217
    fn i8_checked_shl(&mut self, arg0: i8, arg1: u32) -> Option<i8>;
218
    fn i8_wrapping_shl(&mut self, arg0: i8, arg1: u32) -> i8;
219
    fn i8_shl(&mut self, arg0: i8, arg1: u32) -> i8;
220
    fn i8_checked_shr(&mut self, arg0: i8, arg1: u32) -> Option<i8>;
221
    fn i8_wrapping_shr(&mut self, arg0: i8, arg1: u32) -> i8;
222
    fn i8_shr(&mut self, arg0: i8, arg1: u32) -> i8;
223
    fn i8_is_zero(&mut self, arg0: i8) -> bool;
224
    fn i8_matches_zero(&mut self, arg0: i8) -> Option<bool>;
225
    fn i8_is_non_zero(&mut self, arg0: i8) -> bool;
226
    fn i8_matches_non_zero(&mut self, arg0: i8) -> Option<bool>;
227
    fn i8_is_odd(&mut self, arg0: i8) -> bool;
228
    fn i8_matches_odd(&mut self, arg0: i8) -> Option<bool>;
229
    fn i8_is_even(&mut self, arg0: i8) -> bool;
230
    fn i8_matches_even(&mut self, arg0: i8) -> Option<bool>;
231
    fn i8_checked_ilog2(&mut self, arg0: i8) -> Option<u32>;
232
    fn i8_ilog2(&mut self, arg0: i8) -> u32;
233
    fn i8_trailing_zeros(&mut self, arg0: i8) -> u32;
234
    fn i8_trailing_ones(&mut self, arg0: i8) -> u32;
235
    fn i8_leading_zeros(&mut self, arg0: i8) -> u32;
236
    fn i8_leading_ones(&mut self, arg0: i8) -> u32;
237
    fn i8_checked_neg(&mut self, arg0: i8) -> Option<i8>;
238
    fn i8_wrapping_neg(&mut self, arg0: i8) -> i8;
239
    fn i8_neg(&mut self, arg0: i8) -> i8;
240
    fn u8_eq(&mut self, arg0: u8, arg1: u8) -> bool;
241
    fn u8_ne(&mut self, arg0: u8, arg1: u8) -> bool;
242
    fn u8_lt(&mut self, arg0: u8, arg1: u8) -> bool;
243
    fn u8_lt_eq(&mut self, arg0: u8, arg1: u8) -> bool;
244
    fn u8_gt(&mut self, arg0: u8, arg1: u8) -> bool;
245
    fn u8_gt_eq(&mut self, arg0: u8, arg1: u8) -> bool;
246
    fn u8_checked_add(&mut self, arg0: u8, arg1: u8) -> Option<u8>;
247
    fn u8_wrapping_add(&mut self, arg0: u8, arg1: u8) -> u8;
248
    fn u8_add(&mut self, arg0: u8, arg1: u8) -> u8;
249
    fn u8_checked_sub(&mut self, arg0: u8, arg1: u8) -> Option<u8>;
250
    fn u8_wrapping_sub(&mut self, arg0: u8, arg1: u8) -> u8;
251
    fn u8_sub(&mut self, arg0: u8, arg1: u8) -> u8;
252
    fn u8_checked_mul(&mut self, arg0: u8, arg1: u8) -> Option<u8>;
253
    fn u8_wrapping_mul(&mut self, arg0: u8, arg1: u8) -> u8;
254
    fn u8_mul(&mut self, arg0: u8, arg1: u8) -> u8;
255
    fn u8_checked_div(&mut self, arg0: u8, arg1: u8) -> Option<u8>;
256
    fn u8_wrapping_div(&mut self, arg0: u8, arg1: u8) -> u8;
257
    fn u8_div(&mut self, arg0: u8, arg1: u8) -> u8;
258
    fn u8_checked_rem(&mut self, arg0: u8, arg1: u8) -> Option<u8>;
259
    fn u8_rem(&mut self, arg0: u8, arg1: u8) -> u8;
260
    fn u8_and(&mut self, arg0: u8, arg1: u8) -> u8;
261
    fn u8_or(&mut self, arg0: u8, arg1: u8) -> u8;
262
    fn u8_xor(&mut self, arg0: u8, arg1: u8) -> u8;
263
    fn u8_not(&mut self, arg0: u8) -> u8;
264
    fn u8_checked_shl(&mut self, arg0: u8, arg1: u32) -> Option<u8>;
265
    fn u8_wrapping_shl(&mut self, arg0: u8, arg1: u32) -> u8;
266
    fn u8_shl(&mut self, arg0: u8, arg1: u32) -> u8;
267
    fn u8_checked_shr(&mut self, arg0: u8, arg1: u32) -> Option<u8>;
268
    fn u8_wrapping_shr(&mut self, arg0: u8, arg1: u32) -> u8;
269
    fn u8_shr(&mut self, arg0: u8, arg1: u32) -> u8;
270
    fn u8_is_zero(&mut self, arg0: u8) -> bool;
271
    fn u8_matches_zero(&mut self, arg0: u8) -> Option<bool>;
272
    fn u8_is_non_zero(&mut self, arg0: u8) -> bool;
273
    fn u8_matches_non_zero(&mut self, arg0: u8) -> Option<bool>;
274
    fn u8_is_odd(&mut self, arg0: u8) -> bool;
275
    fn u8_matches_odd(&mut self, arg0: u8) -> Option<bool>;
276
    fn u8_is_even(&mut self, arg0: u8) -> bool;
277
    fn u8_matches_even(&mut self, arg0: u8) -> Option<bool>;
278
    fn u8_checked_ilog2(&mut self, arg0: u8) -> Option<u32>;
279
    fn u8_ilog2(&mut self, arg0: u8) -> u32;
280
    fn u8_trailing_zeros(&mut self, arg0: u8) -> u32;
281
    fn u8_trailing_ones(&mut self, arg0: u8) -> u32;
282
    fn u8_leading_zeros(&mut self, arg0: u8) -> u32;
283
    fn u8_leading_ones(&mut self, arg0: u8) -> u32;
284
    fn u8_is_power_of_two(&mut self, arg0: u8) -> bool;
285
    fn u8_matches_power_of_two(&mut self, arg0: u8) -> Option<bool>;
286
    fn i16_eq(&mut self, arg0: i16, arg1: i16) -> bool;
287
    fn i16_ne(&mut self, arg0: i16, arg1: i16) -> bool;
288
    fn i16_lt(&mut self, arg0: i16, arg1: i16) -> bool;
289
    fn i16_lt_eq(&mut self, arg0: i16, arg1: i16) -> bool;
290
    fn i16_gt(&mut self, arg0: i16, arg1: i16) -> bool;
291
    fn i16_gt_eq(&mut self, arg0: i16, arg1: i16) -> bool;
292
    fn i16_checked_add(&mut self, arg0: i16, arg1: i16) -> Option<i16>;
293
    fn i16_wrapping_add(&mut self, arg0: i16, arg1: i16) -> i16;
294
    fn i16_add(&mut self, arg0: i16, arg1: i16) -> i16;
295
    fn i16_checked_sub(&mut self, arg0: i16, arg1: i16) -> Option<i16>;
296
    fn i16_wrapping_sub(&mut self, arg0: i16, arg1: i16) -> i16;
297
    fn i16_sub(&mut self, arg0: i16, arg1: i16) -> i16;
298
    fn i16_checked_mul(&mut self, arg0: i16, arg1: i16) -> Option<i16>;
299
    fn i16_wrapping_mul(&mut self, arg0: i16, arg1: i16) -> i16;
300
    fn i16_mul(&mut self, arg0: i16, arg1: i16) -> i16;
301
    fn i16_checked_div(&mut self, arg0: i16, arg1: i16) -> Option<i16>;
302
    fn i16_wrapping_div(&mut self, arg0: i16, arg1: i16) -> i16;
303
    fn i16_div(&mut self, arg0: i16, arg1: i16) -> i16;
304
    fn i16_checked_rem(&mut self, arg0: i16, arg1: i16) -> Option<i16>;
305
    fn i16_rem(&mut self, arg0: i16, arg1: i16) -> i16;
306
    fn i16_and(&mut self, arg0: i16, arg1: i16) -> i16;
307
    fn i16_or(&mut self, arg0: i16, arg1: i16) -> i16;
308
    fn i16_xor(&mut self, arg0: i16, arg1: i16) -> i16;
309
    fn i16_not(&mut self, arg0: i16) -> i16;
310
    fn i16_checked_shl(&mut self, arg0: i16, arg1: u32) -> Option<i16>;
311
    fn i16_wrapping_shl(&mut self, arg0: i16, arg1: u32) -> i16;
312
    fn i16_shl(&mut self, arg0: i16, arg1: u32) -> i16;
313
    fn i16_checked_shr(&mut self, arg0: i16, arg1: u32) -> Option<i16>;
314
    fn i16_wrapping_shr(&mut self, arg0: i16, arg1: u32) -> i16;
315
    fn i16_shr(&mut self, arg0: i16, arg1: u32) -> i16;
316
    fn i16_is_zero(&mut self, arg0: i16) -> bool;
317
    fn i16_matches_zero(&mut self, arg0: i16) -> Option<bool>;
318
    fn i16_is_non_zero(&mut self, arg0: i16) -> bool;
319
    fn i16_matches_non_zero(&mut self, arg0: i16) -> Option<bool>;
320
    fn i16_is_odd(&mut self, arg0: i16) -> bool;
321
    fn i16_matches_odd(&mut self, arg0: i16) -> Option<bool>;
322
    fn i16_is_even(&mut self, arg0: i16) -> bool;
323
    fn i16_matches_even(&mut self, arg0: i16) -> Option<bool>;
324
    fn i16_checked_ilog2(&mut self, arg0: i16) -> Option<u32>;
325
    fn i16_ilog2(&mut self, arg0: i16) -> u32;
326
    fn i16_trailing_zeros(&mut self, arg0: i16) -> u32;
327
    fn i16_trailing_ones(&mut self, arg0: i16) -> u32;
328
    fn i16_leading_zeros(&mut self, arg0: i16) -> u32;
329
    fn i16_leading_ones(&mut self, arg0: i16) -> u32;
330
    fn i16_checked_neg(&mut self, arg0: i16) -> Option<i16>;
331
    fn i16_wrapping_neg(&mut self, arg0: i16) -> i16;
332
    fn i16_neg(&mut self, arg0: i16) -> i16;
333
    fn u16_eq(&mut self, arg0: u16, arg1: u16) -> bool;
334
    fn u16_ne(&mut self, arg0: u16, arg1: u16) -> bool;
335
    fn u16_lt(&mut self, arg0: u16, arg1: u16) -> bool;
336
    fn u16_lt_eq(&mut self, arg0: u16, arg1: u16) -> bool;
337
    fn u16_gt(&mut self, arg0: u16, arg1: u16) -> bool;
338
    fn u16_gt_eq(&mut self, arg0: u16, arg1: u16) -> bool;
339
    fn u16_checked_add(&mut self, arg0: u16, arg1: u16) -> Option<u16>;
340
    fn u16_wrapping_add(&mut self, arg0: u16, arg1: u16) -> u16;
341
    fn u16_add(&mut self, arg0: u16, arg1: u16) -> u16;
342
    fn u16_checked_sub(&mut self, arg0: u16, arg1: u16) -> Option<u16>;
343
    fn u16_wrapping_sub(&mut self, arg0: u16, arg1: u16) -> u16;
344
    fn u16_sub(&mut self, arg0: u16, arg1: u16) -> u16;
345
    fn u16_checked_mul(&mut self, arg0: u16, arg1: u16) -> Option<u16>;
346
    fn u16_wrapping_mul(&mut self, arg0: u16, arg1: u16) -> u16;
347
    fn u16_mul(&mut self, arg0: u16, arg1: u16) -> u16;
348
    fn u16_checked_div(&mut self, arg0: u16, arg1: u16) -> Option<u16>;
349
    fn u16_wrapping_div(&mut self, arg0: u16, arg1: u16) -> u16;
350
    fn u16_div(&mut self, arg0: u16, arg1: u16) -> u16;
351
    fn u16_checked_rem(&mut self, arg0: u16, arg1: u16) -> Option<u16>;
352
    fn u16_rem(&mut self, arg0: u16, arg1: u16) -> u16;
353
    fn u16_and(&mut self, arg0: u16, arg1: u16) -> u16;
354
    fn u16_or(&mut self, arg0: u16, arg1: u16) -> u16;
355
    fn u16_xor(&mut self, arg0: u16, arg1: u16) -> u16;
356
    fn u16_not(&mut self, arg0: u16) -> u16;
357
    fn u16_checked_shl(&mut self, arg0: u16, arg1: u32) -> Option<u16>;
358
    fn u16_wrapping_shl(&mut self, arg0: u16, arg1: u32) -> u16;
359
    fn u16_shl(&mut self, arg0: u16, arg1: u32) -> u16;
360
    fn u16_checked_shr(&mut self, arg0: u16, arg1: u32) -> Option<u16>;
361
    fn u16_wrapping_shr(&mut self, arg0: u16, arg1: u32) -> u16;
362
    fn u16_shr(&mut self, arg0: u16, arg1: u32) -> u16;
363
    fn u16_is_zero(&mut self, arg0: u16) -> bool;
364
    fn u16_matches_zero(&mut self, arg0: u16) -> Option<bool>;
365
    fn u16_is_non_zero(&mut self, arg0: u16) -> bool;
366
    fn u16_matches_non_zero(&mut self, arg0: u16) -> Option<bool>;
367
    fn u16_is_odd(&mut self, arg0: u16) -> bool;
368
    fn u16_matches_odd(&mut self, arg0: u16) -> Option<bool>;
369
    fn u16_is_even(&mut self, arg0: u16) -> bool;
370
    fn u16_matches_even(&mut self, arg0: u16) -> Option<bool>;
371
    fn u16_checked_ilog2(&mut self, arg0: u16) -> Option<u32>;
372
    fn u16_ilog2(&mut self, arg0: u16) -> u32;
373
    fn u16_trailing_zeros(&mut self, arg0: u16) -> u32;
374
    fn u16_trailing_ones(&mut self, arg0: u16) -> u32;
375
    fn u16_leading_zeros(&mut self, arg0: u16) -> u32;
376
    fn u16_leading_ones(&mut self, arg0: u16) -> u32;
377
    fn u16_is_power_of_two(&mut self, arg0: u16) -> bool;
378
    fn u16_matches_power_of_two(&mut self, arg0: u16) -> Option<bool>;
379
    fn i32_eq(&mut self, arg0: i32, arg1: i32) -> bool;
380
    fn i32_ne(&mut self, arg0: i32, arg1: i32) -> bool;
381
    fn i32_lt(&mut self, arg0: i32, arg1: i32) -> bool;
382
    fn i32_lt_eq(&mut self, arg0: i32, arg1: i32) -> bool;
383
    fn i32_gt(&mut self, arg0: i32, arg1: i32) -> bool;
384
    fn i32_gt_eq(&mut self, arg0: i32, arg1: i32) -> bool;
385
    fn i32_checked_add(&mut self, arg0: i32, arg1: i32) -> Option<i32>;
386
    fn i32_wrapping_add(&mut self, arg0: i32, arg1: i32) -> i32;
387
    fn i32_add(&mut self, arg0: i32, arg1: i32) -> i32;
388
    fn i32_checked_sub(&mut self, arg0: i32, arg1: i32) -> Option<i32>;
389
    fn i32_wrapping_sub(&mut self, arg0: i32, arg1: i32) -> i32;
390
    fn i32_sub(&mut self, arg0: i32, arg1: i32) -> i32;
391
    fn i32_checked_mul(&mut self, arg0: i32, arg1: i32) -> Option<i32>;
392
    fn i32_wrapping_mul(&mut self, arg0: i32, arg1: i32) -> i32;
393
    fn i32_mul(&mut self, arg0: i32, arg1: i32) -> i32;
394
    fn i32_checked_div(&mut self, arg0: i32, arg1: i32) -> Option<i32>;
395
    fn i32_wrapping_div(&mut self, arg0: i32, arg1: i32) -> i32;
396
    fn i32_div(&mut self, arg0: i32, arg1: i32) -> i32;
397
    fn i32_checked_rem(&mut self, arg0: i32, arg1: i32) -> Option<i32>;
398
    fn i32_rem(&mut self, arg0: i32, arg1: i32) -> i32;
399
    fn i32_and(&mut self, arg0: i32, arg1: i32) -> i32;
400
    fn i32_or(&mut self, arg0: i32, arg1: i32) -> i32;
401
    fn i32_xor(&mut self, arg0: i32, arg1: i32) -> i32;
402
    fn i32_not(&mut self, arg0: i32) -> i32;
403
    fn i32_checked_shl(&mut self, arg0: i32, arg1: u32) -> Option<i32>;
404
    fn i32_wrapping_shl(&mut self, arg0: i32, arg1: u32) -> i32;
405
    fn i32_shl(&mut self, arg0: i32, arg1: u32) -> i32;
406
    fn i32_checked_shr(&mut self, arg0: i32, arg1: u32) -> Option<i32>;
407
    fn i32_wrapping_shr(&mut self, arg0: i32, arg1: u32) -> i32;
408
    fn i32_shr(&mut self, arg0: i32, arg1: u32) -> i32;
409
    fn i32_is_zero(&mut self, arg0: i32) -> bool;
410
    fn i32_matches_zero(&mut self, arg0: i32) -> Option<bool>;
411
    fn i32_is_non_zero(&mut self, arg0: i32) -> bool;
412
    fn i32_matches_non_zero(&mut self, arg0: i32) -> Option<bool>;
413
    fn i32_is_odd(&mut self, arg0: i32) -> bool;
414
    fn i32_matches_odd(&mut self, arg0: i32) -> Option<bool>;
415
    fn i32_is_even(&mut self, arg0: i32) -> bool;
416
    fn i32_matches_even(&mut self, arg0: i32) -> Option<bool>;
417
    fn i32_checked_ilog2(&mut self, arg0: i32) -> Option<u32>;
418
    fn i32_ilog2(&mut self, arg0: i32) -> u32;
419
    fn i32_trailing_zeros(&mut self, arg0: i32) -> u32;
420
    fn i32_trailing_ones(&mut self, arg0: i32) -> u32;
421
    fn i32_leading_zeros(&mut self, arg0: i32) -> u32;
422
    fn i32_leading_ones(&mut self, arg0: i32) -> u32;
423
    fn i32_checked_neg(&mut self, arg0: i32) -> Option<i32>;
424
    fn i32_wrapping_neg(&mut self, arg0: i32) -> i32;
425
    fn i32_neg(&mut self, arg0: i32) -> i32;
426
    fn u32_eq(&mut self, arg0: u32, arg1: u32) -> bool;
427
    fn u32_ne(&mut self, arg0: u32, arg1: u32) -> bool;
428
    fn u32_lt(&mut self, arg0: u32, arg1: u32) -> bool;
429
    fn u32_lt_eq(&mut self, arg0: u32, arg1: u32) -> bool;
430
    fn u32_gt(&mut self, arg0: u32, arg1: u32) -> bool;
431
    fn u32_gt_eq(&mut self, arg0: u32, arg1: u32) -> bool;
432
    fn u32_checked_add(&mut self, arg0: u32, arg1: u32) -> Option<u32>;
433
    fn u32_wrapping_add(&mut self, arg0: u32, arg1: u32) -> u32;
434
    fn u32_add(&mut self, arg0: u32, arg1: u32) -> u32;
435
    fn u32_checked_sub(&mut self, arg0: u32, arg1: u32) -> Option<u32>;
436
    fn u32_wrapping_sub(&mut self, arg0: u32, arg1: u32) -> u32;
437
    fn u32_sub(&mut self, arg0: u32, arg1: u32) -> u32;
438
    fn u32_checked_mul(&mut self, arg0: u32, arg1: u32) -> Option<u32>;
439
    fn u32_wrapping_mul(&mut self, arg0: u32, arg1: u32) -> u32;
440
    fn u32_mul(&mut self, arg0: u32, arg1: u32) -> u32;
441
    fn u32_checked_div(&mut self, arg0: u32, arg1: u32) -> Option<u32>;
442
    fn u32_wrapping_div(&mut self, arg0: u32, arg1: u32) -> u32;
443
    fn u32_div(&mut self, arg0: u32, arg1: u32) -> u32;
444
    fn u32_checked_rem(&mut self, arg0: u32, arg1: u32) -> Option<u32>;
445
    fn u32_rem(&mut self, arg0: u32, arg1: u32) -> u32;
446
    fn u32_and(&mut self, arg0: u32, arg1: u32) -> u32;
447
    fn u32_or(&mut self, arg0: u32, arg1: u32) -> u32;
448
    fn u32_xor(&mut self, arg0: u32, arg1: u32) -> u32;
449
    fn u32_not(&mut self, arg0: u32) -> u32;
450
    fn u32_checked_shl(&mut self, arg0: u32, arg1: u32) -> Option<u32>;
451
    fn u32_wrapping_shl(&mut self, arg0: u32, arg1: u32) -> u32;
452
    fn u32_shl(&mut self, arg0: u32, arg1: u32) -> u32;
453
    fn u32_checked_shr(&mut self, arg0: u32, arg1: u32) -> Option<u32>;
454
    fn u32_wrapping_shr(&mut self, arg0: u32, arg1: u32) -> u32;
455
    fn u32_shr(&mut self, arg0: u32, arg1: u32) -> u32;
456
    fn u32_is_zero(&mut self, arg0: u32) -> bool;
457
    fn u32_matches_zero(&mut self, arg0: u32) -> Option<bool>;
458
    fn u32_is_non_zero(&mut self, arg0: u32) -> bool;
459
    fn u32_matches_non_zero(&mut self, arg0: u32) -> Option<bool>;
460
    fn u32_is_odd(&mut self, arg0: u32) -> bool;
461
    fn u32_matches_odd(&mut self, arg0: u32) -> Option<bool>;
462
    fn u32_is_even(&mut self, arg0: u32) -> bool;
463
    fn u32_matches_even(&mut self, arg0: u32) -> Option<bool>;
464
    fn u32_checked_ilog2(&mut self, arg0: u32) -> Option<u32>;
465
    fn u32_ilog2(&mut self, arg0: u32) -> u32;
466
    fn u32_trailing_zeros(&mut self, arg0: u32) -> u32;
467
    fn u32_trailing_ones(&mut self, arg0: u32) -> u32;
468
    fn u32_leading_zeros(&mut self, arg0: u32) -> u32;
469
    fn u32_leading_ones(&mut self, arg0: u32) -> u32;
470
    fn u32_is_power_of_two(&mut self, arg0: u32) -> bool;
471
    fn u32_matches_power_of_two(&mut self, arg0: u32) -> Option<bool>;
472
    fn i64_eq(&mut self, arg0: i64, arg1: i64) -> bool;
473
    fn i64_ne(&mut self, arg0: i64, arg1: i64) -> bool;
474
    fn i64_lt(&mut self, arg0: i64, arg1: i64) -> bool;
475
    fn i64_lt_eq(&mut self, arg0: i64, arg1: i64) -> bool;
476
    fn i64_gt(&mut self, arg0: i64, arg1: i64) -> bool;
477
    fn i64_gt_eq(&mut self, arg0: i64, arg1: i64) -> bool;
478
    fn i64_checked_add(&mut self, arg0: i64, arg1: i64) -> Option<i64>;
479
    fn i64_wrapping_add(&mut self, arg0: i64, arg1: i64) -> i64;
480
    fn i64_add(&mut self, arg0: i64, arg1: i64) -> i64;
481
    fn i64_checked_sub(&mut self, arg0: i64, arg1: i64) -> Option<i64>;
482
    fn i64_wrapping_sub(&mut self, arg0: i64, arg1: i64) -> i64;
483
    fn i64_sub(&mut self, arg0: i64, arg1: i64) -> i64;
484
    fn i64_checked_mul(&mut self, arg0: i64, arg1: i64) -> Option<i64>;
485
    fn i64_wrapping_mul(&mut self, arg0: i64, arg1: i64) -> i64;
486
    fn i64_mul(&mut self, arg0: i64, arg1: i64) -> i64;
487
    fn i64_checked_div(&mut self, arg0: i64, arg1: i64) -> Option<i64>;
488
    fn i64_wrapping_div(&mut self, arg0: i64, arg1: i64) -> i64;
489
    fn i64_div(&mut self, arg0: i64, arg1: i64) -> i64;
490
    fn i64_checked_rem(&mut self, arg0: i64, arg1: i64) -> Option<i64>;
491
    fn i64_rem(&mut self, arg0: i64, arg1: i64) -> i64;
492
    fn i64_and(&mut self, arg0: i64, arg1: i64) -> i64;
493
    fn i64_or(&mut self, arg0: i64, arg1: i64) -> i64;
494
    fn i64_xor(&mut self, arg0: i64, arg1: i64) -> i64;
495
    fn i64_not(&mut self, arg0: i64) -> i64;
496
    fn i64_checked_shl(&mut self, arg0: i64, arg1: u32) -> Option<i64>;
497
    fn i64_wrapping_shl(&mut self, arg0: i64, arg1: u32) -> i64;
498
    fn i64_shl(&mut self, arg0: i64, arg1: u32) -> i64;
499
    fn i64_checked_shr(&mut self, arg0: i64, arg1: u32) -> Option<i64>;
500
    fn i64_wrapping_shr(&mut self, arg0: i64, arg1: u32) -> i64;
501
    fn i64_shr(&mut self, arg0: i64, arg1: u32) -> i64;
502
    fn i64_is_zero(&mut self, arg0: i64) -> bool;
503
    fn i64_matches_zero(&mut self, arg0: i64) -> Option<bool>;
504
    fn i64_is_non_zero(&mut self, arg0: i64) -> bool;
505
    fn i64_matches_non_zero(&mut self, arg0: i64) -> Option<bool>;
506
    fn i64_is_odd(&mut self, arg0: i64) -> bool;
507
    fn i64_matches_odd(&mut self, arg0: i64) -> Option<bool>;
508
    fn i64_is_even(&mut self, arg0: i64) -> bool;
509
    fn i64_matches_even(&mut self, arg0: i64) -> Option<bool>;
510
    fn i64_checked_ilog2(&mut self, arg0: i64) -> Option<u32>;
511
    fn i64_ilog2(&mut self, arg0: i64) -> u32;
512
    fn i64_trailing_zeros(&mut self, arg0: i64) -> u32;
513
    fn i64_trailing_ones(&mut self, arg0: i64) -> u32;
514
    fn i64_leading_zeros(&mut self, arg0: i64) -> u32;
515
    fn i64_leading_ones(&mut self, arg0: i64) -> u32;
516
    fn i64_checked_neg(&mut self, arg0: i64) -> Option<i64>;
517
    fn i64_wrapping_neg(&mut self, arg0: i64) -> i64;
518
    fn i64_neg(&mut self, arg0: i64) -> i64;
519
    fn u64_eq(&mut self, arg0: u64, arg1: u64) -> bool;
520
    fn u64_ne(&mut self, arg0: u64, arg1: u64) -> bool;
521
    fn u64_lt(&mut self, arg0: u64, arg1: u64) -> bool;
522
    fn u64_lt_eq(&mut self, arg0: u64, arg1: u64) -> bool;
523
    fn u64_gt(&mut self, arg0: u64, arg1: u64) -> bool;
524
    fn u64_gt_eq(&mut self, arg0: u64, arg1: u64) -> bool;
525
    fn u64_checked_add(&mut self, arg0: u64, arg1: u64) -> Option<u64>;
526
    fn u64_wrapping_add(&mut self, arg0: u64, arg1: u64) -> u64;
527
    fn u64_add(&mut self, arg0: u64, arg1: u64) -> u64;
528
    fn u64_checked_sub(&mut self, arg0: u64, arg1: u64) -> Option<u64>;
529
    fn u64_wrapping_sub(&mut self, arg0: u64, arg1: u64) -> u64;
530
    fn u64_sub(&mut self, arg0: u64, arg1: u64) -> u64;
531
    fn u64_checked_mul(&mut self, arg0: u64, arg1: u64) -> Option<u64>;
532
    fn u64_wrapping_mul(&mut self, arg0: u64, arg1: u64) -> u64;
533
    fn u64_mul(&mut self, arg0: u64, arg1: u64) -> u64;
534
    fn u64_checked_div(&mut self, arg0: u64, arg1: u64) -> Option<u64>;
535
    fn u64_wrapping_div(&mut self, arg0: u64, arg1: u64) -> u64;
536
    fn u64_div(&mut self, arg0: u64, arg1: u64) -> u64;
537
    fn u64_checked_rem(&mut self, arg0: u64, arg1: u64) -> Option<u64>;
538
    fn u64_rem(&mut self, arg0: u64, arg1: u64) -> u64;
539
    fn u64_and(&mut self, arg0: u64, arg1: u64) -> u64;
540
    fn u64_or(&mut self, arg0: u64, arg1: u64) -> u64;
541
    fn u64_xor(&mut self, arg0: u64, arg1: u64) -> u64;
542
    fn u64_not(&mut self, arg0: u64) -> u64;
543
    fn u64_checked_shl(&mut self, arg0: u64, arg1: u32) -> Option<u64>;
544
    fn u64_wrapping_shl(&mut self, arg0: u64, arg1: u32) -> u64;
545
    fn u64_shl(&mut self, arg0: u64, arg1: u32) -> u64;
546
    fn u64_checked_shr(&mut self, arg0: u64, arg1: u32) -> Option<u64>;
547
    fn u64_wrapping_shr(&mut self, arg0: u64, arg1: u32) -> u64;
548
    fn u64_shr(&mut self, arg0: u64, arg1: u32) -> u64;
549
    fn u64_is_zero(&mut self, arg0: u64) -> bool;
550
    fn u64_matches_zero(&mut self, arg0: u64) -> Option<bool>;
551
    fn u64_is_non_zero(&mut self, arg0: u64) -> bool;
552
    fn u64_matches_non_zero(&mut self, arg0: u64) -> Option<bool>;
553
    fn u64_is_odd(&mut self, arg0: u64) -> bool;
554
    fn u64_matches_odd(&mut self, arg0: u64) -> Option<bool>;
555
    fn u64_is_even(&mut self, arg0: u64) -> bool;
556
    fn u64_matches_even(&mut self, arg0: u64) -> Option<bool>;
557
    fn u64_checked_ilog2(&mut self, arg0: u64) -> Option<u32>;
558
    fn u64_ilog2(&mut self, arg0: u64) -> u32;
559
    fn u64_trailing_zeros(&mut self, arg0: u64) -> u32;
560
    fn u64_trailing_ones(&mut self, arg0: u64) -> u32;
561
    fn u64_leading_zeros(&mut self, arg0: u64) -> u32;
562
    fn u64_leading_ones(&mut self, arg0: u64) -> u32;
563
    fn u64_is_power_of_two(&mut self, arg0: u64) -> bool;
564
    fn u64_matches_power_of_two(&mut self, arg0: u64) -> Option<bool>;
565
    fn i128_eq(&mut self, arg0: i128, arg1: i128) -> bool;
566
    fn i128_ne(&mut self, arg0: i128, arg1: i128) -> bool;
567
    fn i128_lt(&mut self, arg0: i128, arg1: i128) -> bool;
568
    fn i128_lt_eq(&mut self, arg0: i128, arg1: i128) -> bool;
569
    fn i128_gt(&mut self, arg0: i128, arg1: i128) -> bool;
570
    fn i128_gt_eq(&mut self, arg0: i128, arg1: i128) -> bool;
571
    fn i128_checked_add(&mut self, arg0: i128, arg1: i128) -> Option<i128>;
572
    fn i128_wrapping_add(&mut self, arg0: i128, arg1: i128) -> i128;
573
    fn i128_add(&mut self, arg0: i128, arg1: i128) -> i128;
574
    fn i128_checked_sub(&mut self, arg0: i128, arg1: i128) -> Option<i128>;
575
    fn i128_wrapping_sub(&mut self, arg0: i128, arg1: i128) -> i128;
576
    fn i128_sub(&mut self, arg0: i128, arg1: i128) -> i128;
577
    fn i128_checked_mul(&mut self, arg0: i128, arg1: i128) -> Option<i128>;
578
    fn i128_wrapping_mul(&mut self, arg0: i128, arg1: i128) -> i128;
579
    fn i128_mul(&mut self, arg0: i128, arg1: i128) -> i128;
580
    fn i128_checked_div(&mut self, arg0: i128, arg1: i128) -> Option<i128>;
581
    fn i128_wrapping_div(&mut self, arg0: i128, arg1: i128) -> i128;
582
    fn i128_div(&mut self, arg0: i128, arg1: i128) -> i128;
583
    fn i128_checked_rem(&mut self, arg0: i128, arg1: i128) -> Option<i128>;
584
    fn i128_rem(&mut self, arg0: i128, arg1: i128) -> i128;
585
    fn i128_and(&mut self, arg0: i128, arg1: i128) -> i128;
586
    fn i128_or(&mut self, arg0: i128, arg1: i128) -> i128;
587
    fn i128_xor(&mut self, arg0: i128, arg1: i128) -> i128;
588
    fn i128_not(&mut self, arg0: i128) -> i128;
589
    fn i128_checked_shl(&mut self, arg0: i128, arg1: u32) -> Option<i128>;
590
    fn i128_wrapping_shl(&mut self, arg0: i128, arg1: u32) -> i128;
591
    fn i128_shl(&mut self, arg0: i128, arg1: u32) -> i128;
592
    fn i128_checked_shr(&mut self, arg0: i128, arg1: u32) -> Option<i128>;
593
    fn i128_wrapping_shr(&mut self, arg0: i128, arg1: u32) -> i128;
594
    fn i128_shr(&mut self, arg0: i128, arg1: u32) -> i128;
595
    fn i128_is_zero(&mut self, arg0: i128) -> bool;
596
    fn i128_matches_zero(&mut self, arg0: i128) -> Option<bool>;
597
    fn i128_is_non_zero(&mut self, arg0: i128) -> bool;
598
    fn i128_matches_non_zero(&mut self, arg0: i128) -> Option<bool>;
599
    fn i128_is_odd(&mut self, arg0: i128) -> bool;
600
    fn i128_matches_odd(&mut self, arg0: i128) -> Option<bool>;
601
    fn i128_is_even(&mut self, arg0: i128) -> bool;
602
    fn i128_matches_even(&mut self, arg0: i128) -> Option<bool>;
603
    fn i128_checked_ilog2(&mut self, arg0: i128) -> Option<u32>;
604
    fn i128_ilog2(&mut self, arg0: i128) -> u32;
605
    fn i128_trailing_zeros(&mut self, arg0: i128) -> u32;
606
    fn i128_trailing_ones(&mut self, arg0: i128) -> u32;
607
    fn i128_leading_zeros(&mut self, arg0: i128) -> u32;
608
    fn i128_leading_ones(&mut self, arg0: i128) -> u32;
609
    fn i128_checked_neg(&mut self, arg0: i128) -> Option<i128>;
610
    fn i128_wrapping_neg(&mut self, arg0: i128) -> i128;
611
    fn i128_neg(&mut self, arg0: i128) -> i128;
612
    fn u128_eq(&mut self, arg0: u128, arg1: u128) -> bool;
613
    fn u128_ne(&mut self, arg0: u128, arg1: u128) -> bool;
614
    fn u128_lt(&mut self, arg0: u128, arg1: u128) -> bool;
615
    fn u128_lt_eq(&mut self, arg0: u128, arg1: u128) -> bool;
616
    fn u128_gt(&mut self, arg0: u128, arg1: u128) -> bool;
617
    fn u128_gt_eq(&mut self, arg0: u128, arg1: u128) -> bool;
618
    fn u128_checked_add(&mut self, arg0: u128, arg1: u128) -> Option<u128>;
619
    fn u128_wrapping_add(&mut self, arg0: u128, arg1: u128) -> u128;
620
    fn u128_add(&mut self, arg0: u128, arg1: u128) -> u128;
621
    fn u128_checked_sub(&mut self, arg0: u128, arg1: u128) -> Option<u128>;
622
    fn u128_wrapping_sub(&mut self, arg0: u128, arg1: u128) -> u128;
623
    fn u128_sub(&mut self, arg0: u128, arg1: u128) -> u128;
624
    fn u128_checked_mul(&mut self, arg0: u128, arg1: u128) -> Option<u128>;
625
    fn u128_wrapping_mul(&mut self, arg0: u128, arg1: u128) -> u128;
626
    fn u128_mul(&mut self, arg0: u128, arg1: u128) -> u128;
627
    fn u128_checked_div(&mut self, arg0: u128, arg1: u128) -> Option<u128>;
628
    fn u128_wrapping_div(&mut self, arg0: u128, arg1: u128) -> u128;
629
    fn u128_div(&mut self, arg0: u128, arg1: u128) -> u128;
630
    fn u128_checked_rem(&mut self, arg0: u128, arg1: u128) -> Option<u128>;
631
    fn u128_rem(&mut self, arg0: u128, arg1: u128) -> u128;
632
    fn u128_and(&mut self, arg0: u128, arg1: u128) -> u128;
633
    fn u128_or(&mut self, arg0: u128, arg1: u128) -> u128;
634
    fn u128_xor(&mut self, arg0: u128, arg1: u128) -> u128;
635
    fn u128_not(&mut self, arg0: u128) -> u128;
636
    fn u128_checked_shl(&mut self, arg0: u128, arg1: u32) -> Option<u128>;
637
    fn u128_wrapping_shl(&mut self, arg0: u128, arg1: u32) -> u128;
638
    fn u128_shl(&mut self, arg0: u128, arg1: u32) -> u128;
639
    fn u128_checked_shr(&mut self, arg0: u128, arg1: u32) -> Option<u128>;
640
    fn u128_wrapping_shr(&mut self, arg0: u128, arg1: u32) -> u128;
641
    fn u128_shr(&mut self, arg0: u128, arg1: u32) -> u128;
642
    fn u128_is_zero(&mut self, arg0: u128) -> bool;
643
    fn u128_matches_zero(&mut self, arg0: u128) -> Option<bool>;
644
    fn u128_is_non_zero(&mut self, arg0: u128) -> bool;
645
    fn u128_matches_non_zero(&mut self, arg0: u128) -> Option<bool>;
646
    fn u128_is_odd(&mut self, arg0: u128) -> bool;
647
    fn u128_matches_odd(&mut self, arg0: u128) -> Option<bool>;
648
    fn u128_is_even(&mut self, arg0: u128) -> bool;
649
    fn u128_matches_even(&mut self, arg0: u128) -> Option<bool>;
650
    fn u128_checked_ilog2(&mut self, arg0: u128) -> Option<u32>;
651
    fn u128_ilog2(&mut self, arg0: u128) -> u32;
652
    fn u128_trailing_zeros(&mut self, arg0: u128) -> u32;
653
    fn u128_trailing_ones(&mut self, arg0: u128) -> u32;
654
    fn u128_leading_zeros(&mut self, arg0: u128) -> u32;
655
    fn u128_leading_ones(&mut self, arg0: u128) -> u32;
656
    fn u128_is_power_of_two(&mut self, arg0: u128) -> bool;
657
    fn u128_matches_power_of_two(&mut self, arg0: u128) -> Option<bool>;
658
    fn i8_try_into_u8(&mut self, arg0: i8) -> Option<u8>;
659
    fn i8_unwrap_into_u8(&mut self, arg0: i8) -> u8;
660
    fn i8_cast_unsigned(&mut self, arg0: i8) -> u8;
661
    fn i8_from_u8(&mut self, arg0: i8) -> Option<u8>;
662
    fn i8_into_i16(&mut self, arg0: i8) -> i16;
663
    fn i8_from_i16(&mut self, arg0: i8) -> Option<i16>;
664
    fn i8_try_into_u16(&mut self, arg0: i8) -> Option<u16>;
665
    fn i8_unwrap_into_u16(&mut self, arg0: i8) -> u16;
666
    fn i8_from_u16(&mut self, arg0: i8) -> Option<u16>;
667
    fn i8_into_i32(&mut self, arg0: i8) -> i32;
668
    fn i8_from_i32(&mut self, arg0: i8) -> Option<i32>;
669
    fn i8_try_into_u32(&mut self, arg0: i8) -> Option<u32>;
670
    fn i8_unwrap_into_u32(&mut self, arg0: i8) -> u32;
671
    fn i8_from_u32(&mut self, arg0: i8) -> Option<u32>;
672
    fn i8_into_i64(&mut self, arg0: i8) -> i64;
673
    fn i8_from_i64(&mut self, arg0: i8) -> Option<i64>;
674
    fn i8_try_into_u64(&mut self, arg0: i8) -> Option<u64>;
675
    fn i8_unwrap_into_u64(&mut self, arg0: i8) -> u64;
676
    fn i8_from_u64(&mut self, arg0: i8) -> Option<u64>;
677
    fn i8_into_i128(&mut self, arg0: i8) -> i128;
678
    fn i8_from_i128(&mut self, arg0: i8) -> Option<i128>;
679
    fn i8_try_into_u128(&mut self, arg0: i8) -> Option<u128>;
680
    fn i8_unwrap_into_u128(&mut self, arg0: i8) -> u128;
681
    fn i8_from_u128(&mut self, arg0: i8) -> Option<u128>;
682
    fn u8_try_into_i8(&mut self, arg0: u8) -> Option<i8>;
683
    fn u8_unwrap_into_i8(&mut self, arg0: u8) -> i8;
684
    fn u8_cast_signed(&mut self, arg0: u8) -> i8;
685
    fn u8_from_i8(&mut self, arg0: u8) -> Option<i8>;
686
    fn u8_into_i16(&mut self, arg0: u8) -> i16;
687
    fn u8_from_i16(&mut self, arg0: u8) -> Option<i16>;
688
    fn u8_into_u16(&mut self, arg0: u8) -> u16;
689
    fn u8_from_u16(&mut self, arg0: u8) -> Option<u16>;
690
    fn u8_into_i32(&mut self, arg0: u8) -> i32;
691
    fn u8_from_i32(&mut self, arg0: u8) -> Option<i32>;
692
    fn u8_into_u32(&mut self, arg0: u8) -> u32;
693
    fn u8_from_u32(&mut self, arg0: u8) -> Option<u32>;
694
    fn u8_into_i64(&mut self, arg0: u8) -> i64;
695
    fn u8_from_i64(&mut self, arg0: u8) -> Option<i64>;
696
    fn u8_into_u64(&mut self, arg0: u8) -> u64;
697
    fn u8_from_u64(&mut self, arg0: u8) -> Option<u64>;
698
    fn u8_into_i128(&mut self, arg0: u8) -> i128;
699
    fn u8_from_i128(&mut self, arg0: u8) -> Option<i128>;
700
    fn u8_into_u128(&mut self, arg0: u8) -> u128;
701
    fn u8_from_u128(&mut self, arg0: u8) -> Option<u128>;
702
    fn i16_try_into_i8(&mut self, arg0: i16) -> Option<i8>;
703
    fn i16_unwrap_into_i8(&mut self, arg0: i16) -> i8;
704
    fn i16_truncate_into_i8(&mut self, arg0: i16) -> i8;
705
    fn i16_from_i8(&mut self, arg0: i16) -> Option<i8>;
706
    fn i16_try_into_u8(&mut self, arg0: i16) -> Option<u8>;
707
    fn i16_unwrap_into_u8(&mut self, arg0: i16) -> u8;
708
    fn i16_from_u8(&mut self, arg0: i16) -> Option<u8>;
709
    fn i16_try_into_u16(&mut self, arg0: i16) -> Option<u16>;
710
    fn i16_unwrap_into_u16(&mut self, arg0: i16) -> u16;
711
    fn i16_cast_unsigned(&mut self, arg0: i16) -> u16;
712
    fn i16_from_u16(&mut self, arg0: i16) -> Option<u16>;
713
    fn i16_into_i32(&mut self, arg0: i16) -> i32;
714
    fn i16_from_i32(&mut self, arg0: i16) -> Option<i32>;
715
    fn i16_try_into_u32(&mut self, arg0: i16) -> Option<u32>;
716
    fn i16_unwrap_into_u32(&mut self, arg0: i16) -> u32;
717
    fn i16_from_u32(&mut self, arg0: i16) -> Option<u32>;
718
    fn i16_into_i64(&mut self, arg0: i16) -> i64;
719
    fn i16_from_i64(&mut self, arg0: i16) -> Option<i64>;
720
    fn i16_try_into_u64(&mut self, arg0: i16) -> Option<u64>;
721
    fn i16_unwrap_into_u64(&mut self, arg0: i16) -> u64;
722
    fn i16_from_u64(&mut self, arg0: i16) -> Option<u64>;
723
    fn i16_into_i128(&mut self, arg0: i16) -> i128;
724
    fn i16_from_i128(&mut self, arg0: i16) -> Option<i128>;
725
    fn i16_try_into_u128(&mut self, arg0: i16) -> Option<u128>;
726
    fn i16_unwrap_into_u128(&mut self, arg0: i16) -> u128;
727
    fn i16_from_u128(&mut self, arg0: i16) -> Option<u128>;
728
    fn u16_try_into_i8(&mut self, arg0: u16) -> Option<i8>;
729
    fn u16_unwrap_into_i8(&mut self, arg0: u16) -> i8;
730
    fn u16_from_i8(&mut self, arg0: u16) -> Option<i8>;
731
    fn u16_try_into_u8(&mut self, arg0: u16) -> Option<u8>;
732
    fn u16_unwrap_into_u8(&mut self, arg0: u16) -> u8;
733
    fn u16_truncate_into_u8(&mut self, arg0: u16) -> u8;
734
    fn u16_from_u8(&mut self, arg0: u16) -> Option<u8>;
735
    fn u16_try_into_i16(&mut self, arg0: u16) -> Option<i16>;
736
    fn u16_unwrap_into_i16(&mut self, arg0: u16) -> i16;
737
    fn u16_cast_signed(&mut self, arg0: u16) -> i16;
738
    fn u16_from_i16(&mut self, arg0: u16) -> Option<i16>;
739
    fn u16_into_i32(&mut self, arg0: u16) -> i32;
740
    fn u16_from_i32(&mut self, arg0: u16) -> Option<i32>;
741
    fn u16_into_u32(&mut self, arg0: u16) -> u32;
742
    fn u16_from_u32(&mut self, arg0: u16) -> Option<u32>;
743
    fn u16_into_i64(&mut self, arg0: u16) -> i64;
744
    fn u16_from_i64(&mut self, arg0: u16) -> Option<i64>;
745
    fn u16_into_u64(&mut self, arg0: u16) -> u64;
746
    fn u16_from_u64(&mut self, arg0: u16) -> Option<u64>;
747
    fn u16_into_i128(&mut self, arg0: u16) -> i128;
748
    fn u16_from_i128(&mut self, arg0: u16) -> Option<i128>;
749
    fn u16_into_u128(&mut self, arg0: u16) -> u128;
750
    fn u16_from_u128(&mut self, arg0: u16) -> Option<u128>;
751
    fn i32_try_into_i8(&mut self, arg0: i32) -> Option<i8>;
752
    fn i32_unwrap_into_i8(&mut self, arg0: i32) -> i8;
753
    fn i32_truncate_into_i8(&mut self, arg0: i32) -> i8;
754
    fn i32_from_i8(&mut self, arg0: i32) -> Option<i8>;
755
    fn i32_try_into_u8(&mut self, arg0: i32) -> Option<u8>;
756
    fn i32_unwrap_into_u8(&mut self, arg0: i32) -> u8;
757
    fn i32_from_u8(&mut self, arg0: i32) -> Option<u8>;
758
    fn i32_try_into_i16(&mut self, arg0: i32) -> Option<i16>;
759
    fn i32_unwrap_into_i16(&mut self, arg0: i32) -> i16;
760
    fn i32_truncate_into_i16(&mut self, arg0: i32) -> i16;
761
    fn i32_from_i16(&mut self, arg0: i32) -> Option<i16>;
762
    fn i32_try_into_u16(&mut self, arg0: i32) -> Option<u16>;
763
    fn i32_unwrap_into_u16(&mut self, arg0: i32) -> u16;
764
    fn i32_from_u16(&mut self, arg0: i32) -> Option<u16>;
765
    fn i32_try_into_u32(&mut self, arg0: i32) -> Option<u32>;
766
    fn i32_unwrap_into_u32(&mut self, arg0: i32) -> u32;
767
    fn i32_cast_unsigned(&mut self, arg0: i32) -> u32;
768
    fn i32_from_u32(&mut self, arg0: i32) -> Option<u32>;
769
    fn i32_into_i64(&mut self, arg0: i32) -> i64;
770
    fn i32_from_i64(&mut self, arg0: i32) -> Option<i64>;
771
    fn i32_try_into_u64(&mut self, arg0: i32) -> Option<u64>;
772
    fn i32_unwrap_into_u64(&mut self, arg0: i32) -> u64;
773
    fn i32_from_u64(&mut self, arg0: i32) -> Option<u64>;
774
    fn i32_into_i128(&mut self, arg0: i32) -> i128;
775
    fn i32_from_i128(&mut self, arg0: i32) -> Option<i128>;
776
    fn i32_try_into_u128(&mut self, arg0: i32) -> Option<u128>;
777
    fn i32_unwrap_into_u128(&mut self, arg0: i32) -> u128;
778
    fn i32_from_u128(&mut self, arg0: i32) -> Option<u128>;
779
    fn u32_try_into_i8(&mut self, arg0: u32) -> Option<i8>;
780
    fn u32_unwrap_into_i8(&mut self, arg0: u32) -> i8;
781
    fn u32_from_i8(&mut self, arg0: u32) -> Option<i8>;
782
    fn u32_try_into_u8(&mut self, arg0: u32) -> Option<u8>;
783
    fn u32_unwrap_into_u8(&mut self, arg0: u32) -> u8;
784
    fn u32_truncate_into_u8(&mut self, arg0: u32) -> u8;
785
    fn u32_from_u8(&mut self, arg0: u32) -> Option<u8>;
786
    fn u32_try_into_i16(&mut self, arg0: u32) -> Option<i16>;
787
    fn u32_unwrap_into_i16(&mut self, arg0: u32) -> i16;
788
    fn u32_from_i16(&mut self, arg0: u32) -> Option<i16>;
789
    fn u32_try_into_u16(&mut self, arg0: u32) -> Option<u16>;
790
    fn u32_unwrap_into_u16(&mut self, arg0: u32) -> u16;
791
    fn u32_truncate_into_u16(&mut self, arg0: u32) -> u16;
792
    fn u32_from_u16(&mut self, arg0: u32) -> Option<u16>;
793
    fn u32_try_into_i32(&mut self, arg0: u32) -> Option<i32>;
794
    fn u32_unwrap_into_i32(&mut self, arg0: u32) -> i32;
795
    fn u32_cast_signed(&mut self, arg0: u32) -> i32;
796
    fn u32_from_i32(&mut self, arg0: u32) -> Option<i32>;
797
    fn u32_into_i64(&mut self, arg0: u32) -> i64;
798
    fn u32_from_i64(&mut self, arg0: u32) -> Option<i64>;
799
    fn u32_into_u64(&mut self, arg0: u32) -> u64;
800
    fn u32_from_u64(&mut self, arg0: u32) -> Option<u64>;
801
    fn u32_into_i128(&mut self, arg0: u32) -> i128;
802
    fn u32_from_i128(&mut self, arg0: u32) -> Option<i128>;
803
    fn u32_into_u128(&mut self, arg0: u32) -> u128;
804
    fn u32_from_u128(&mut self, arg0: u32) -> Option<u128>;
805
    fn i64_try_into_i8(&mut self, arg0: i64) -> Option<i8>;
806
    fn i64_unwrap_into_i8(&mut self, arg0: i64) -> i8;
807
    fn i64_truncate_into_i8(&mut self, arg0: i64) -> i8;
808
    fn i64_from_i8(&mut self, arg0: i64) -> Option<i8>;
809
    fn i64_try_into_u8(&mut self, arg0: i64) -> Option<u8>;
810
    fn i64_unwrap_into_u8(&mut self, arg0: i64) -> u8;
811
    fn i64_from_u8(&mut self, arg0: i64) -> Option<u8>;
812
    fn i64_try_into_i16(&mut self, arg0: i64) -> Option<i16>;
813
    fn i64_unwrap_into_i16(&mut self, arg0: i64) -> i16;
814
    fn i64_truncate_into_i16(&mut self, arg0: i64) -> i16;
815
    fn i64_from_i16(&mut self, arg0: i64) -> Option<i16>;
816
    fn i64_try_into_u16(&mut self, arg0: i64) -> Option<u16>;
817
    fn i64_unwrap_into_u16(&mut self, arg0: i64) -> u16;
818
    fn i64_from_u16(&mut self, arg0: i64) -> Option<u16>;
819
    fn i64_try_into_i32(&mut self, arg0: i64) -> Option<i32>;
820
    fn i64_unwrap_into_i32(&mut self, arg0: i64) -> i32;
821
    fn i64_truncate_into_i32(&mut self, arg0: i64) -> i32;
822
    fn i64_from_i32(&mut self, arg0: i64) -> Option<i32>;
823
    fn i64_try_into_u32(&mut self, arg0: i64) -> Option<u32>;
824
    fn i64_unwrap_into_u32(&mut self, arg0: i64) -> u32;
825
    fn i64_from_u32(&mut self, arg0: i64) -> Option<u32>;
826
    fn i64_try_into_u64(&mut self, arg0: i64) -> Option<u64>;
827
    fn i64_unwrap_into_u64(&mut self, arg0: i64) -> u64;
828
    fn i64_cast_unsigned(&mut self, arg0: i64) -> u64;
829
    fn i64_from_u64(&mut self, arg0: i64) -> Option<u64>;
830
    fn i64_into_i128(&mut self, arg0: i64) -> i128;
831
    fn i64_from_i128(&mut self, arg0: i64) -> Option<i128>;
832
    fn i64_try_into_u128(&mut self, arg0: i64) -> Option<u128>;
833
    fn i64_unwrap_into_u128(&mut self, arg0: i64) -> u128;
834
    fn i64_from_u128(&mut self, arg0: i64) -> Option<u128>;
835
    fn u64_try_into_i8(&mut self, arg0: u64) -> Option<i8>;
836
    fn u64_unwrap_into_i8(&mut self, arg0: u64) -> i8;
837
    fn u64_from_i8(&mut self, arg0: u64) -> Option<i8>;
838
    fn u64_try_into_u8(&mut self, arg0: u64) -> Option<u8>;
839
    fn u64_unwrap_into_u8(&mut self, arg0: u64) -> u8;
840
    fn u64_truncate_into_u8(&mut self, arg0: u64) -> u8;
841
    fn u64_from_u8(&mut self, arg0: u64) -> Option<u8>;
842
    fn u64_try_into_i16(&mut self, arg0: u64) -> Option<i16>;
843
    fn u64_unwrap_into_i16(&mut self, arg0: u64) -> i16;
844
    fn u64_from_i16(&mut self, arg0: u64) -> Option<i16>;
845
    fn u64_try_into_u16(&mut self, arg0: u64) -> Option<u16>;
846
    fn u64_unwrap_into_u16(&mut self, arg0: u64) -> u16;
847
    fn u64_truncate_into_u16(&mut self, arg0: u64) -> u16;
848
    fn u64_from_u16(&mut self, arg0: u64) -> Option<u16>;
849
    fn u64_try_into_i32(&mut self, arg0: u64) -> Option<i32>;
850
    fn u64_unwrap_into_i32(&mut self, arg0: u64) -> i32;
851
    fn u64_from_i32(&mut self, arg0: u64) -> Option<i32>;
852
    fn u64_try_into_u32(&mut self, arg0: u64) -> Option<u32>;
853
    fn u64_unwrap_into_u32(&mut self, arg0: u64) -> u32;
854
    fn u64_truncate_into_u32(&mut self, arg0: u64) -> u32;
855
    fn u64_from_u32(&mut self, arg0: u64) -> Option<u32>;
856
    fn u64_try_into_i64(&mut self, arg0: u64) -> Option<i64>;
857
    fn u64_unwrap_into_i64(&mut self, arg0: u64) -> i64;
858
    fn u64_cast_signed(&mut self, arg0: u64) -> i64;
859
    fn u64_from_i64(&mut self, arg0: u64) -> Option<i64>;
860
    fn u64_into_i128(&mut self, arg0: u64) -> i128;
861
    fn u64_from_i128(&mut self, arg0: u64) -> Option<i128>;
862
    fn u64_into_u128(&mut self, arg0: u64) -> u128;
863
    fn u64_from_u128(&mut self, arg0: u64) -> Option<u128>;
864
    fn i128_try_into_i8(&mut self, arg0: i128) -> Option<i8>;
865
    fn i128_unwrap_into_i8(&mut self, arg0: i128) -> i8;
866
    fn i128_truncate_into_i8(&mut self, arg0: i128) -> i8;
867
    fn i128_from_i8(&mut self, arg0: i128) -> Option<i8>;
868
    fn i128_try_into_u8(&mut self, arg0: i128) -> Option<u8>;
869
    fn i128_unwrap_into_u8(&mut self, arg0: i128) -> u8;
870
    fn i128_from_u8(&mut self, arg0: i128) -> Option<u8>;
871
    fn i128_try_into_i16(&mut self, arg0: i128) -> Option<i16>;
872
    fn i128_unwrap_into_i16(&mut self, arg0: i128) -> i16;
873
    fn i128_truncate_into_i16(&mut self, arg0: i128) -> i16;
874
    fn i128_from_i16(&mut self, arg0: i128) -> Option<i16>;
875
    fn i128_try_into_u16(&mut self, arg0: i128) -> Option<u16>;
876
    fn i128_unwrap_into_u16(&mut self, arg0: i128) -> u16;
877
    fn i128_from_u16(&mut self, arg0: i128) -> Option<u16>;
878
    fn i128_try_into_i32(&mut self, arg0: i128) -> Option<i32>;
879
    fn i128_unwrap_into_i32(&mut self, arg0: i128) -> i32;
880
    fn i128_truncate_into_i32(&mut self, arg0: i128) -> i32;
881
    fn i128_from_i32(&mut self, arg0: i128) -> Option<i32>;
882
    fn i128_try_into_u32(&mut self, arg0: i128) -> Option<u32>;
883
    fn i128_unwrap_into_u32(&mut self, arg0: i128) -> u32;
884
    fn i128_from_u32(&mut self, arg0: i128) -> Option<u32>;
885
    fn i128_try_into_i64(&mut self, arg0: i128) -> Option<i64>;
886
    fn i128_unwrap_into_i64(&mut self, arg0: i128) -> i64;
887
    fn i128_truncate_into_i64(&mut self, arg0: i128) -> i64;
888
    fn i128_from_i64(&mut self, arg0: i128) -> Option<i64>;
889
    fn i128_try_into_u64(&mut self, arg0: i128) -> Option<u64>;
890
    fn i128_unwrap_into_u64(&mut self, arg0: i128) -> u64;
891
    fn i128_from_u64(&mut self, arg0: i128) -> Option<u64>;
892
    fn i128_try_into_u128(&mut self, arg0: i128) -> Option<u128>;
893
    fn i128_unwrap_into_u128(&mut self, arg0: i128) -> u128;
894
    fn i128_cast_unsigned(&mut self, arg0: i128) -> u128;
895
    fn i128_from_u128(&mut self, arg0: i128) -> Option<u128>;
896
    fn u128_try_into_i8(&mut self, arg0: u128) -> Option<i8>;
897
    fn u128_unwrap_into_i8(&mut self, arg0: u128) -> i8;
898
    fn u128_from_i8(&mut self, arg0: u128) -> Option<i8>;
899
    fn u128_try_into_u8(&mut self, arg0: u128) -> Option<u8>;
900
    fn u128_unwrap_into_u8(&mut self, arg0: u128) -> u8;
901
    fn u128_truncate_into_u8(&mut self, arg0: u128) -> u8;
902
    fn u128_from_u8(&mut self, arg0: u128) -> Option<u8>;
903
    fn u128_try_into_i16(&mut self, arg0: u128) -> Option<i16>;
904
    fn u128_unwrap_into_i16(&mut self, arg0: u128) -> i16;
905
    fn u128_from_i16(&mut self, arg0: u128) -> Option<i16>;
906
    fn u128_try_into_u16(&mut self, arg0: u128) -> Option<u16>;
907
    fn u128_unwrap_into_u16(&mut self, arg0: u128) -> u16;
908
    fn u128_truncate_into_u16(&mut self, arg0: u128) -> u16;
909
    fn u128_from_u16(&mut self, arg0: u128) -> Option<u16>;
910
    fn u128_try_into_i32(&mut self, arg0: u128) -> Option<i32>;
911
    fn u128_unwrap_into_i32(&mut self, arg0: u128) -> i32;
912
    fn u128_from_i32(&mut self, arg0: u128) -> Option<i32>;
913
    fn u128_try_into_u32(&mut self, arg0: u128) -> Option<u32>;
914
    fn u128_unwrap_into_u32(&mut self, arg0: u128) -> u32;
915
    fn u128_truncate_into_u32(&mut self, arg0: u128) -> u32;
916
    fn u128_from_u32(&mut self, arg0: u128) -> Option<u32>;
917
    fn u128_try_into_i64(&mut self, arg0: u128) -> Option<i64>;
918
    fn u128_unwrap_into_i64(&mut self, arg0: u128) -> i64;
919
    fn u128_from_i64(&mut self, arg0: u128) -> Option<i64>;
920
    fn u128_try_into_u64(&mut self, arg0: u128) -> Option<u64>;
921
    fn u128_unwrap_into_u64(&mut self, arg0: u128) -> u64;
922
    fn u128_truncate_into_u64(&mut self, arg0: u128) -> u64;
923
    fn u128_from_u64(&mut self, arg0: u128) -> Option<u64>;
924
    fn u128_try_into_i128(&mut self, arg0: u128) -> Option<i128>;
925
    fn u128_unwrap_into_i128(&mut self, arg0: u128) -> i128;
926
    fn u128_cast_signed(&mut self, arg0: u128) -> i128;
927
    fn u128_from_i128(&mut self, arg0: u128) -> Option<i128>;
928
    fn unpack_value_array_2(&mut self, arg0: &ValueArray2) -> (Value, Value);
929
    fn pack_value_array_2(&mut self, arg0: Value, arg1: Value) -> ValueArray2;
930
    fn unpack_value_array_3(&mut self, arg0: &ValueArray3) -> (Value, Value, Value);
931
    fn pack_value_array_3(&mut self, arg0: Value, arg1: Value, arg2: Value) -> ValueArray3;
932
    fn unpack_block_array_2(&mut self, arg0: &BlockArray2) -> (BlockCall, BlockCall);
933
    fn pack_block_array_2(&mut self, arg0: BlockCall, arg1: BlockCall) -> BlockArray2;
934
}
935
936
pub trait ContextIter {
937
    type Context;
938
    type Output;
939
    fn next(&mut self, ctx: &mut Self::Context) -> Option<Self::Output>;
940
0
    fn size_hint(&self) -> (usize, Option<usize>) { (0, None) }
941
}
942
943
pub trait IntoContextIter {
944
    type Context;
945
    type Output;
946
    type IntoIter: ContextIter<Context = Self::Context, Output = Self::Output>;
947
    fn into_context_iter(self) -> Self::IntoIter;
948
}
949
950
pub trait Length {
951
    fn len(&self) -> usize;
952
}
953
954
impl<T> Length for std::vec::Vec<T> {
955
0
    fn len(&self) -> usize {
956
0
        std::vec::Vec::len(self)
957
0
    }
958
}
959
960
pub struct ContextIterWrapper<I, C> {
961
    iter: I,
962
    _ctx: std::marker::PhantomData<C>,
963
}
964
impl<I: Default, C> Default for ContextIterWrapper<I, C> {
965
59.2k
    fn default() -> Self {
966
59.2k
        ContextIterWrapper {
967
59.2k
            iter: I::default(),
968
59.2k
            _ctx: std::marker::PhantomData
969
59.2k
        }
970
59.2k
    }
971
}
972
impl<I, C> std::ops::Deref for ContextIterWrapper<I, C> {
973
    type Target = I;
974
0
    fn deref(&self) -> &I {
975
0
        &self.iter
976
0
    }
977
}
978
impl<I, C> std::ops::DerefMut for ContextIterWrapper<I, C> {
979
0
    fn deref_mut(&mut self) -> &mut I {
980
0
        &mut self.iter
981
0
    }
982
}
983
impl<I: Iterator, C: Context> From<I> for ContextIterWrapper<I, C> {
984
0
    fn from(iter: I) -> Self {
985
0
        Self { iter, _ctx: std::marker::PhantomData }
986
0
    }
987
}
988
impl<I: Iterator, C: Context> ContextIter for ContextIterWrapper<I, C> {
989
    type Context = C;
990
    type Output = I::Item;
991
85.3k
    fn next(&mut self, _ctx: &mut Self::Context) -> Option<Self::Output> {
992
85.3k
        self.iter.next()
993
85.3k
    }
994
0
    fn size_hint(&self) -> (usize, Option<usize>) {
995
0
        self.iter.size_hint()
996
0
    }
997
}
998
impl<I: IntoIterator, C: Context> IntoContextIter for ContextIterWrapper<I, C> {
999
    type Context = C;
1000
    type Output = I::Item;
1001
    type IntoIter = ContextIterWrapper<I::IntoIter, C>;
1002
59.2k
    fn into_context_iter(self) -> Self::IntoIter {
1003
59.2k
        ContextIterWrapper {
1004
59.2k
            iter: self.iter.into_iter(),
1005
59.2k
            _ctx: std::marker::PhantomData
1006
59.2k
        }
1007
59.2k
    }
1008
}
1009
impl<T, E: Extend<T>, C> Extend<T> for ContextIterWrapper<E, C> {
1010
26.0k
    fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I) {
1011
26.0k
        self.iter.extend(iter);
1012
26.0k
    }
1013
}
1014
impl<L: Length, C> Length for ContextIterWrapper<L, C> {
1015
26.0k
    fn len(&self) -> usize {
1016
26.0k
        self.iter.len()
1017
26.0k
    }
1018
}
1019
           
1020
1021
/// Internal type SkeletonInstSimplification: defined at src/prelude_opt.isle line 63.
1022
#[derive(Clone, Debug)]
1023
pub enum SkeletonInstSimplification {
1024
    Remove,
1025
    RemoveWithVal {
1026
        val: Value,
1027
    },
1028
    Replace {
1029
        inst: Inst,
1030
    },
1031
    ReplaceWithVal {
1032
        inst: Inst,
1033
        val: Value,
1034
    },
1035
}
1036
1037
/// Internal type DivConstMagicU32: defined at src/prelude_opt.isle line 229.
1038
#[derive(Clone, Debug)]
1039
pub enum DivConstMagicU32 {
1040
    U32 {
1041
        mul_by: u32,
1042
        do_add: bool,
1043
        shift_by: u32,
1044
    },
1045
}
1046
1047
/// Internal type DivConstMagicU64: defined at src/prelude_opt.isle line 232.
1048
#[derive(Clone, Debug)]
1049
pub enum DivConstMagicU64 {
1050
    U64 {
1051
        mul_by: u64,
1052
        do_add: bool,
1053
        shift_by: u32,
1054
    },
1055
}
1056
1057
/// Internal type DivConstMagicS32: defined at src/prelude_opt.isle line 235.
1058
#[derive(Clone, Debug)]
1059
pub enum DivConstMagicS32 {
1060
    S32 {
1061
        mul_by: i32,
1062
        shift_by: u32,
1063
    },
1064
}
1065
1066
/// Internal type DivConstMagicS64: defined at src/prelude_opt.isle line 237.
1067
#[derive(Clone, Debug)]
1068
pub enum DivConstMagicS64 {
1069
    S64 {
1070
        mul_by: i64,
1071
        shift_by: u32,
1072
    },
1073
}
1074
1075
// Generated as internal constructor for term ty_shift_mask.
1076
78.0k
pub fn constructor_ty_shift_mask<C: Context>(
1077
78.0k
    ctx: &mut C,
1078
78.0k
    arg0: Type,
1079
78.0k
) -> u64 {
1080
78.0k
    let v1 = C::lane_type(ctx, arg0);
1081
78.0k
    let v2 = C::ty_bits(ctx, v1);
1082
78.0k
    let v3 = C::u8_into_u64(ctx, v2);
1083
78.0k
    let v5 = C::u64_sub(ctx, v3, 0x1_u64);
1084
    // Rule at src/prelude.isle line 284.
1085
78.0k
    return v5;
1086
78.0k
}
1087
1088
// Generated as internal constructor for term spaceship_s.
1089
132
pub fn constructor_spaceship_s<C: Context>(
1090
132
    ctx: &mut C,
1091
132
    arg0: Type,
1092
132
    arg1: Value,
1093
132
    arg2: Value,
1094
132
) -> Value {
1095
132
    let v4 = constructor_sgt(ctx, arg0, arg1, arg2);
1096
132
    let v5 = constructor_slt(ctx, arg0, arg1, arg2);
1097
132
    let v6 = constructor_isub(ctx, I8, v4, v5);
1098
    // Rule at src/prelude_opt.isle line 51.
1099
132
    return v6;
1100
132
}
1101
1102
// Generated as internal constructor for term spaceship_u.
1103
207
pub fn constructor_spaceship_u<C: Context>(
1104
207
    ctx: &mut C,
1105
207
    arg0: Type,
1106
207
    arg1: Value,
1107
207
    arg2: Value,
1108
207
) -> Value {
1109
207
    let v4 = constructor_ugt(ctx, arg0, arg1, arg2);
1110
207
    let v5 = constructor_ult(ctx, arg0, arg1, arg2);
1111
207
    let v6 = constructor_isub(ctx, I8, v4, v5);
1112
    // Rule at src/prelude_opt.isle line 54.
1113
207
    return v6;
1114
207
}
1115
1116
// Generated as internal constructor for term simplify.
1117
5.42M
pub fn constructor_simplify<C: Context>(
1118
5.42M
    ctx: &mut C,
1119
5.42M
    arg0: Value,
1120
5.42M
    returns: &mut (impl Extend<Value> + Length),
1121
5.42M
) -> () {
1122
5.42M
    let mut v1 = C::inst_data_value_etor_returns::default();
1123
5.42M
    C::inst_data_value_etor(ctx, arg0, &mut v1);
1124
5.42M
    let mut v1 = v1.into_context_iter();
1125
10.8M
    while let Some(
v25.42M
) = v1.next(ctx) {
1126
5.42M
        match &v2.1 {
1127
            &InstructionData::Binary {
1128
3.01M
                opcode: ref v5,
1129
3.01M
                args: ref v6,
1130
            } => {
1131
3.01M
                match v5 {
1132
                    &Opcode::Smin => {
1133
0
                        let v7 = C::unpack_value_array_2(ctx, v6);
1134
0
                        let mut v10 = C::inst_data_value_etor_returns::default();
1135
0
                        C::inst_data_value_etor(ctx, v7.1, &mut v10);
1136
0
                        let mut v10 = v10.into_context_iter();
1137
0
                        while let Some(v11) = v10.next(ctx) {
1138
                            if let &InstructionData::Unary {
1139
0
                                opcode: ref v26,
1140
0
                                arg: v27,
1141
0
                            } = &v11.1 {
1142
0
                                if let &Opcode::Splat = v26 {
1143
0
                                    if v2.0 == v11.0 {
1144
0
                                        let mut v18 = C::inst_data_value_etor_returns::default();
1145
0
                                        C::inst_data_value_etor(ctx, v7.0, &mut v18);
1146
0
                                        let mut v18 = v18.into_context_iter();
1147
0
                                        while let Some(v19) = v18.next(ctx) {
1148
                                            if let &InstructionData::Unary {
1149
0
                                                opcode: ref v29,
1150
0
                                                arg: v30,
1151
0
                                            } = &v19.1 {
1152
0
                                                if let &Opcode::Splat = v29 {
1153
0
                                                    if v2.0 == v19.0 {
1154
0
                                                        let v1262 = C::lane_type(ctx, v2.0);
1155
0
                                                        let v1406 = constructor_smin(ctx, v1262, v30, v27);
1156
0
                                                        let v1407 = constructor_splat(ctx, v2.0, v1406);
1157
                                                        // Rule at src/opts/vector.isle line 54.
1158
0
                                                        returns.extend(Some(v1407));
1159
0
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
1160
0
                                                    }
1161
0
                                                }
1162
0
                                            }
1163
                                        }
1164
0
                                    }
1165
0
                                }
1166
0
                            }
1167
                        }
1168
                    }
1169
                    &Opcode::Umin => {
1170
1.60k
                        let v7 = C::unpack_value_array_2(ctx, v6);
1171
1.60k
                        let mut v10 = C::inst_data_value_etor_returns::default();
1172
1.60k
                        C::inst_data_value_etor(ctx, v7.1, &mut v10);
1173
1.60k
                        let mut v10 = v10.into_context_iter();
1174
2.91k
                        while let Some(
v111.30k
) = v10.next(ctx) {
1175
                            if let &InstructionData::Unary {
1176
53
                                opcode: ref v26,
1177
53
                                arg: v27,
1178
1.30k
                            } = &v11.1 {
1179
53
                                if let &Opcode::Splat = v26 {
1180
0
                                    if v2.0 == v11.0 {
1181
0
                                        let mut v18 = C::inst_data_value_etor_returns::default();
1182
0
                                        C::inst_data_value_etor(ctx, v7.0, &mut v18);
1183
0
                                        let mut v18 = v18.into_context_iter();
1184
0
                                        while let Some(v19) = v18.next(ctx) {
1185
                                            if let &InstructionData::Unary {
1186
0
                                                opcode: ref v29,
1187
0
                                                arg: v30,
1188
0
                                            } = &v19.1 {
1189
0
                                                if let &Opcode::Splat = v29 {
1190
0
                                                    if v2.0 == v19.0 {
1191
0
                                                        let v1262 = C::lane_type(ctx, v2.0);
1192
0
                                                        let v1408 = constructor_umin(ctx, v1262, v30, v27);
1193
0
                                                        let v1409 = constructor_splat(ctx, v2.0, v1408);
1194
                                                        // Rule at src/opts/vector.isle line 57.
1195
0
                                                        returns.extend(Some(v1409));
1196
0
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
1197
0
                                                    }
1198
0
                                                }
1199
0
                                            }
1200
                                        }
1201
0
                                    }
1202
53
                                }
1203
1.25k
                            }
1204
                        }
1205
                    }
1206
                    &Opcode::Smax => {
1207
0
                        let v7 = C::unpack_value_array_2(ctx, v6);
1208
0
                        let mut v10 = C::inst_data_value_etor_returns::default();
1209
0
                        C::inst_data_value_etor(ctx, v7.1, &mut v10);
1210
0
                        let mut v10 = v10.into_context_iter();
1211
0
                        while let Some(v11) = v10.next(ctx) {
1212
                            if let &InstructionData::Unary {
1213
0
                                opcode: ref v26,
1214
0
                                arg: v27,
1215
0
                            } = &v11.1 {
1216
0
                                if let &Opcode::Splat = v26 {
1217
0
                                    if v2.0 == v11.0 {
1218
0
                                        let mut v18 = C::inst_data_value_etor_returns::default();
1219
0
                                        C::inst_data_value_etor(ctx, v7.0, &mut v18);
1220
0
                                        let mut v18 = v18.into_context_iter();
1221
0
                                        while let Some(v19) = v18.next(ctx) {
1222
                                            if let &InstructionData::Unary {
1223
0
                                                opcode: ref v29,
1224
0
                                                arg: v30,
1225
0
                                            } = &v19.1 {
1226
0
                                                if let &Opcode::Splat = v29 {
1227
0
                                                    if v2.0 == v19.0 {
1228
0
                                                        let v1262 = C::lane_type(ctx, v2.0);
1229
0
                                                        let v1410 = constructor_smax(ctx, v1262, v30, v27);
1230
0
                                                        let v1411 = constructor_splat(ctx, v2.0, v1410);
1231
                                                        // Rule at src/opts/vector.isle line 60.
1232
0
                                                        returns.extend(Some(v1411));
1233
0
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
1234
0
                                                    }
1235
0
                                                }
1236
0
                                            }
1237
                                        }
1238
0
                                    }
1239
0
                                }
1240
0
                            }
1241
                        }
1242
                    }
1243
                    &Opcode::Umax => {
1244
2.81k
                        let v7 = C::unpack_value_array_2(ctx, v6);
1245
2.81k
                        let mut v10 = C::inst_data_value_etor_returns::default();
1246
2.81k
                        C::inst_data_value_etor(ctx, v7.1, &mut v10);
1247
2.81k
                        let mut v10 = v10.into_context_iter();
1248
5.41k
                        while let Some(
v112.60k
) = v10.next(ctx) {
1249
                            if let &InstructionData::Unary {
1250
2
                                opcode: ref v26,
1251
2
                                arg: v27,
1252
2.60k
                            } = &v11.1 {
1253
2
                                if let &Opcode::Splat = v26 {
1254
0
                                    if v2.0 == v11.0 {
1255
0
                                        let mut v18 = C::inst_data_value_etor_returns::default();
1256
0
                                        C::inst_data_value_etor(ctx, v7.0, &mut v18);
1257
0
                                        let mut v18 = v18.into_context_iter();
1258
0
                                        while let Some(v19) = v18.next(ctx) {
1259
                                            if let &InstructionData::Unary {
1260
0
                                                opcode: ref v29,
1261
0
                                                arg: v30,
1262
0
                                            } = &v19.1 {
1263
0
                                                if let &Opcode::Splat = v29 {
1264
0
                                                    if v2.0 == v19.0 {
1265
0
                                                        let v1262 = C::lane_type(ctx, v2.0);
1266
0
                                                        let v1412 = constructor_umax(ctx, v1262, v30, v27);
1267
0
                                                        let v1413 = constructor_splat(ctx, v2.0, v1412);
1268
                                                        // Rule at src/opts/vector.isle line 63.
1269
0
                                                        returns.extend(Some(v1413));
1270
0
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
1271
0
                                                    }
1272
0
                                                }
1273
0
                                            }
1274
                                        }
1275
0
                                    }
1276
2
                                }
1277
2.59k
                            }
1278
                        }
1279
                    }
1280
                    &Opcode::Iadd => {
1281
2.69M
                        let v7 = C::unpack_value_array_2(ctx, v6);
1282
2.69M
                        let mut v18 = C::inst_data_value_etor_returns::default();
1283
2.69M
                        C::inst_data_value_etor(ctx, v7.0, &mut v18);
1284
2.69M
                        let mut v18 = v18.into_context_iter();
1285
5.26M
                        while let Some(
v192.57M
) = v18.next(ctx) {
1286
2.57M
                            match &v19.1 {
1287
                                &InstructionData::Binary {
1288
894k
                                    opcode: ref v122,
1289
894k
                                    args: ref v123,
1290
                                } => {
1291
894k
                                    match v122 {
1292
                                        &Opcode::Iadd => {
1293
693k
                                            if v2.0 == v19.0 {
1294
693k
                                                let mut v10 = C::inst_data_value_etor_returns::default();
1295
693k
                                                C::inst_data_value_etor(ctx, v7.1, &mut v10);
1296
693k
                                                let mut v10 = v10.into_context_iter();
1297
1.39M
                                                while let Some(
v11698k
) = v10.next(ctx) {
1298
698k
                                                    match &v11.1 {
1299
                                                        &InstructionData::Binary {
1300
30.1k
                                                            opcode: ref v104,
1301
30.1k
                                                            args: ref v105,
1302
                                                        } => {
1303
30.1k
                                                            if let &Opcode::Iadd = v104 {
1304
24.5k
                                                                if v2.0 == v11.0 {
1305
24.5k
                                                                    let v106 = C::unpack_value_array_2(ctx, v105);
1306
24.5k
                                                                    let mut v109 = C::inst_data_value_etor_returns::default();
1307
24.5k
                                                                    C::inst_data_value_etor(ctx, v106.1, &mut v109);
1308
24.5k
                                                                    let mut v109 = v109.into_context_iter();
1309
53.1k
                                                                    while let Some(
v11028.6k
) = v109.next(ctx) {
1310
                                                                        if let &InstructionData::UnaryImm {
1311
2.89k
                                                                            opcode: ref v724,
1312
2.89k
                                                                            imm: v725,
1313
28.6k
                                                                        } = &v110.1 {
1314
2.89k
                                                                            if let &Opcode::Iconst = v724 {
1315
2.89k
                                                                                let v124 = C::unpack_value_array_2(ctx, v123);
1316
2.89k
                                                                                let mut v199 = C::inst_data_value_etor_returns::default();
1317
2.89k
                                                                                C::inst_data_value_etor(ctx, v124.1, &mut v199);
1318
2.89k
                                                                                let mut v199 = v199.into_context_iter();
1319
5.68k
                                                                                while let Some(
v2002.78k
) = v199.next(ctx) {
1320
                                                                                    if let &InstructionData::UnaryImm {
1321
1.78k
                                                                                        opcode: ref v241,
1322
1.78k
                                                                                        imm: v242,
1323
2.78k
                                                                                    } = &v200.1 {
1324
1.78k
                                                                                        if let &Opcode::Iconst = v241 {
1325
1.78k
                                                                                            let v726 = constructor_iadd(ctx, v2.0, v124.0, v106.0);
1326
1.78k
                                                                                            let v727 = constructor_iadd(ctx, v2.0, v124.1, v106.1);
1327
1.78k
                                                                                            let v728 = constructor_iadd(ctx, v2.0, v726, v727);
1328
                                                                                            // Rule at src/opts/cprop.isle line 241.
1329
1.78k
                                                                                            returns.extend(Some(v728));
1330
1.78k
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
1331
0
                                                                                        }
1332
997
                                                                                    }
1333
                                                                                }
1334
0
                                                                            }
1335
25.7k
                                                                        }
1336
                                                                    }
1337
0
                                                                }
1338
5.54k
                                                            }
1339
                                                        }
1340
                                                        &InstructionData::UnaryImm {
1341
653k
                                                            opcode: ref v14,
1342
653k
                                                            imm: v15,
1343
                                                        } => {
1344
653k
                                                            if let &Opcode::Iconst = v14 {
1345
653k
                                                                if v2.0 == v11.0 {
1346
653k
                                                                    let v124 = C::unpack_value_array_2(ctx, v123);
1347
653k
                                                                    let mut v199 = C::inst_data_value_etor_returns::default();
1348
653k
                                                                    C::inst_data_value_etor(ctx, v124.1, &mut v199);
1349
653k
                                                                    let mut v199 = v199.into_context_iter();
1350
1.29M
                                                                    while let Some(
v200638k
) = v199.next(ctx) {
1351
                                                                        if let &InstructionData::UnaryImm {
1352
149k
                                                                            opcode: ref v241,
1353
149k
                                                                            imm: v242,
1354
638k
                                                                        } = &v200.1 {
1355
149k
                                                                            if let &Opcode::Iconst = v241 {
1356
149k
                                                                                if v2.0 == v200.0 {
1357
149k
                                                                                    let v616 = constructor_iadd(ctx, v2.0, v124.1, v7.1);
1358
149k
                                                                                    let v617 = constructor_iadd(ctx, v2.0, v124.0, v616);
1359
                                                                                    // Rule at src/opts/cprop.isle line 123.
1360
149k
                                                                                    returns.extend(Some(v617));
1361
149k
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
1362
0
                                                                                }
1363
0
                                                                            }
1364
488k
                                                                        }
1365
                                                                    }
1366
0
                                                                }
1367
0
                                                            }
1368
                                                        }
1369
14.8k
                                                        _ => {}
1370
                                                    }
1371
                                                }
1372
693k
                                                let v124 = C::unpack_value_array_2(ctx, v123);
1373
693k
                                                let mut v127 = C::inst_data_value_etor_returns::default();
1374
693k
                                                C::inst_data_value_etor(ctx, v124.0, &mut v127);
1375
693k
                                                let mut v127 = v127.into_context_iter();
1376
1.35M
                                                while let Some(
v128665k
) = v127.next(ctx) {
1377
                                                    if let &InstructionData::Binary {
1378
94.2k
                                                        opcode: ref v131,
1379
94.2k
                                                        args: ref v132,
1380
665k
                                                    } = &v128.1 {
1381
94.2k
                                                        match v131 {
1382
                                                            &Opcode::Iadd => {
1383
18.8k
                                                                if v2.0 == v128.0 {
1384
18.8k
                                                                    let v133 = C::unpack_value_array_2(ctx, v132);
1385
18.8k
                                                                    let v136 = constructor_iadd(ctx, v2.0, v133.0, v133.1);
1386
18.8k
                                                                    let v137 = constructor_iadd(ctx, v2.0, v124.1, v7.1);
1387
18.8k
                                                                    let v138 = constructor_iadd(ctx, v2.0, v136, v137);
1388
18.8k
                                                                    let v139 = C::subsume(ctx, v138);
1389
                                                                    // Rule at src/opts/arithmetic.isle line 214.
1390
18.8k
                                                                    returns.extend(Some(v139));
1391
18.8k
                                                                    if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
1392
0
                                                                }
1393
                                                            }
1394
                                                            &Opcode::Isub => {
1395
71.3k
                                                                if v2.0 == v128.0 {
1396
71.3k
                                                                    let v133 = C::unpack_value_array_2(ctx, v132);
1397
71.3k
                                                                    let v180 = constructor_isub(ctx, v2.0, v133.0, v133.1);
1398
71.3k
                                                                    let v137 = constructor_iadd(ctx, v2.0, v124.1, v7.1);
1399
71.3k
                                                                    let v188 = constructor_iadd(ctx, v2.0, v180, v137);
1400
71.3k
                                                                    let v189 = C::subsume(ctx, v188);
1401
                                                                    // Rule at src/opts/arithmetic.isle line 278.
1402
71.3k
                                                                    returns.extend(Some(v189));
1403
71.3k
                                                                    if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
1404
0
                                                                }
1405
                                                            }
1406
3.98k
                                                            _ => {}
1407
                                                        }
1408
571k
                                                    }
1409
                                                }
1410
0
                                            }
1411
                                        }
1412
                                        &Opcode::Isub => {
1413
187k
                                            if v2.0 == v19.0 {
1414
187k
                                                let v124 = C::unpack_value_array_2(ctx, v123);
1415
187k
                                                let mut v127 = C::inst_data_value_etor_returns::default();
1416
187k
                                                C::inst_data_value_etor(ctx, v124.0, &mut v127);
1417
187k
                                                let mut v127 = v127.into_context_iter();
1418
374k
                                                while let Some(
v128186k
) = v127.next(ctx) {
1419
186k
                                                    match &v128.1 {
1420
                                                        &InstructionData::Binary {
1421
349
                                                            opcode: ref v131,
1422
349
                                                            args: ref v132,
1423
                                                        } => {
1424
349
                                                            match v131 {
1425
                                                                &Opcode::Iadd => {
1426
53
                                                                    if v2.0 == v128.0 {
1427
53
                                                                        let v133 = C::unpack_value_array_2(ctx, v132);
1428
53
                                                                        let v136 = constructor_iadd(ctx, v2.0, v133.0, v133.1);
1429
53
                                                                        let v183 = constructor_isub(ctx, v2.0, v124.1, v7.1);
1430
53
                                                                        let v192 = constructor_isub(ctx, v2.0, v136, v183);
1431
53
                                                                        let v193 = C::subsume(ctx, v192);
1432
                                                                        // Rule at src/opts/arithmetic.isle line 286.
1433
53
                                                                        returns.extend(Some(v193));
1434
53
                                                                        if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
1435
0
                                                                    }
1436
                                                                }
1437
                                                                &Opcode::Isub => {
1438
197
                                                                    if v2.0 == v128.0 {
1439
197
                                                                        let v133 = C::unpack_value_array_2(ctx, v132);
1440
197
                                                                        let v180 = constructor_isub(ctx, v2.0, v133.0, v133.1);
1441
197
                                                                        let v183 = constructor_isub(ctx, v2.0, v124.1, v7.1);
1442
197
                                                                        let v184 = constructor_isub(ctx, v2.0, v180, v183);
1443
197
                                                                        let v185 = C::subsume(ctx, v184);
1444
                                                                        // Rule at src/opts/arithmetic.isle line 270.
1445
197
                                                                        returns.extend(Some(v185));
1446
197
                                                                        if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
1447
0
                                                                    }
1448
                                                                }
1449
99
                                                                _ => {}
1450
                                                            }
1451
                                                        }
1452
                                                        &InstructionData::UnaryImm {
1453
519
                                                            opcode: ref v622,
1454
519
                                                            imm: v623,
1455
                                                        } => {
1456
519
                                                            if let &Opcode::Iconst = v622 {
1457
519
                                                                if v2.0 == v128.0 {
1458
519
                                                                    let mut v10 = C::inst_data_value_etor_returns::default();
1459
519
                                                                    C::inst_data_value_etor(ctx, v7.1, &mut v10);
1460
519
                                                                    let mut v10 = v10.into_context_iter();
1461
995
                                                                    while let Some(
v11476
) = v10.next(ctx) {
1462
                                                                        if let &InstructionData::UnaryImm {
1463
0
                                                                            opcode: ref v14,
1464
0
                                                                            imm: v15,
1465
476
                                                                        } = &v11.1 {
1466
0
                                                                            if let &Opcode::Iconst = v14 {
1467
0
                                                                                if v2.0 == v11.0 {
1468
0
                                                                                    let v624 = C::u64_from_imm64(ctx, v623);
1469
0
                                                                                    let v16 = C::u64_from_imm64(ctx, v15);
1470
0
                                                                                    let v634 = C::u64_wrapping_add(ctx, v624, v16);
1471
0
                                                                                    let v635 = C::imm64_masked(ctx, v2.0, v634);
1472
0
                                                                                    let v636 = constructor_iconst(ctx, v2.0, v635);
1473
0
                                                                                    let v637 = constructor_isub(ctx, v2.0, v636, v124.1);
1474
                                                                                    // Rule at src/opts/cprop.isle line 149.
1475
0
                                                                                    returns.extend(Some(v637));
1476
0
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
1477
0
                                                                                }
1478
0
                                                                            }
1479
476
                                                                        }
1480
                                                                    }
1481
0
                                                                }
1482
0
                                                            }
1483
                                                        }
1484
186k
                                                        _ => {}
1485
                                                    }
1486
                                                }
1487
187k
                                                let mut v10 = C::inst_data_value_etor_returns::default();
1488
187k
                                                C::inst_data_value_etor(ctx, v7.1, &mut v10);
1489
187k
                                                let mut v10 = v10.into_context_iter();
1490
376k
                                                while let Some(
v11189k
) = v10.next(ctx) {
1491
                                                    if let &InstructionData::UnaryImm {
1492
182k
                                                        opcode: ref v14,
1493
182k
                                                        imm: v15,
1494
189k
                                                    } = &v11.1 {
1495
182k
                                                        if let &Opcode::Iconst = v14 {
1496
182k
                                                            if v2.0 == v11.0 {
1497
182k
                                                                let mut v199 = C::inst_data_value_etor_returns::default();
1498
182k
                                                                C::inst_data_value_etor(ctx, v124.1, &mut v199);
1499
182k
                                                                let mut v199 = v199.into_context_iter();
1500
365k
                                                                while let Some(
v200182k
) = v199.next(ctx) {
1501
                                                                    if let &InstructionData::UnaryImm {
1502
181k
                                                                        opcode: ref v241,
1503
181k
                                                                        imm: v242,
1504
182k
                                                                    } = &v200.1 {
1505
181k
                                                                        if let &Opcode::Iconst = v241 {
1506
181k
                                                                            if v2.0 == v200.0 {
1507
181k
                                                                                let v16 = C::u64_from_imm64(ctx, v15);
1508
181k
                                                                                let v243 = C::u64_from_imm64(ctx, v242);
1509
181k
                                                                                let v629 = C::u64_wrapping_sub(ctx, v16, v243);
1510
181k
                                                                                let v630 = C::imm64_masked(ctx, v2.0, v629);
1511
181k
                                                                                let v631 = constructor_iconst(ctx, v2.0, v630);
1512
181k
                                                                                let v633 = constructor_iadd(ctx, v2.0, v124.0, v631);
1513
                                                                                // Rule at src/opts/cprop.isle line 145.
1514
181k
                                                                                returns.extend(Some(v633));
1515
181k
                                                                                if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
1516
0
                                                                            }
1517
0
                                                                        }
1518
682
                                                                    }
1519
                                                                }
1520
0
                                                            }
1521
0
                                                        }
1522
6.54k
                                                    }
1523
                                                }
1524
0
                                            }
1525
                                        }
1526
                                        &Opcode::Bor => {
1527
1.40k
                                            if v2.0 == v19.0 {
1528
1.40k
                                                let mut v58 = C::inst_data_value_tupled_etor_returns::default();
1529
1.40k
                                                C::inst_data_value_tupled_etor(ctx, v7.1, &mut v58);
1530
1.40k
                                                let mut v58 = v58.into_context_iter();
1531
2.82k
                                                while let Some(
v591.42k
) = v58.next(ctx) {
1532
1.42k
                                                    let v60 = C::iconst_sextend_etor(ctx, v59);
1533
1.42k
                                                    if let Some(
v611.33k
) = v60 {
1534
1.33k
                                                        if v2.0 == v61.0 {
1535
1.33k
                                                            let v124 = C::unpack_value_array_2(ctx, v123);
1536
1.33k
                                                            let mut v217 = C::inst_data_value_tupled_etor_returns::default();
1537
1.33k
                                                            C::inst_data_value_tupled_etor(ctx, v124.1, &mut v217);
1538
1.33k
                                                            let mut v217 = v217.into_context_iter();
1539
2.67k
                                                            while let Some(
v2181.33k
) = v217.next(ctx) {
1540
1.33k
                                                                let v219 = C::iconst_sextend_etor(ctx, v218);
1541
1.33k
                                                                if let Some(
v2201.26k
) = v219 {
1542
1.26k
                                                                    let v223 = C::i64_checked_neg(ctx, v220.1);
1543
1.26k
                                                                    if let Some(v224) = v223 {
1544
1.26k
                                                                        if v2.0 == v220.0 {
1545
1.26k
                                                                            if v61.1 == v224 {
1546
0
                                                                                let v225 = C::i64_not(ctx, v220.1);
1547
0
                                                                                let v226 = C::i64_cast_unsigned(ctx, v225);
1548
0
                                                                                let v227 = C::imm64_masked(ctx, v2.0, v226);
1549
0
                                                                                let v228 = constructor_iconst(ctx, v2.0, v227);
1550
0
                                                                                let v229 = constructor_band(ctx, v2.0, v124.0, v228);
1551
                                                                                // Rule at src/opts/arithmetic.isle line 322.
1552
0
                                                                                returns.extend(Some(v229));
1553
0
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
1554
1.26k
                                                                            }
1555
0
                                                                        }
1556
0
                                                                    }
1557
75
                                                                }
1558
                                                            }
1559
0
                                                        }
1560
84
                                                    }
1561
                                                }
1562
0
                                            }
1563
                                        }
1564
12.0k
                                        _ => {}
1565
                                    }
1566
                                }
1567
                                &InstructionData::Unary {
1568
5.14k
                                    opcode: ref v29,
1569
5.14k
                                    arg: v30,
1570
                                } => {
1571
5.14k
                                    match v29 {
1572
                                        &Opcode::Splat => {
1573
0
                                            if v2.0 == v19.0 {
1574
0
                                                let mut v10 = C::inst_data_value_etor_returns::default();
1575
0
                                                C::inst_data_value_etor(ctx, v7.1, &mut v10);
1576
0
                                                let mut v10 = v10.into_context_iter();
1577
0
                                                while let Some(v11) = v10.next(ctx) {
1578
                                                    if let &InstructionData::Unary {
1579
0
                                                        opcode: ref v26,
1580
0
                                                        arg: v27,
1581
0
                                                    } = &v11.1 {
1582
0
                                                        if let &Opcode::Splat = v26 {
1583
0
                                                            if v2.0 == v11.0 {
1584
0
                                                                let v1262 = C::lane_type(ctx, v2.0);
1585
0
                                                                let v1390 = constructor_iadd(ctx, v1262, v30, v27);
1586
0
                                                                let v1391 = constructor_splat(ctx, v2.0, v1390);
1587
                                                                // Rule at src/opts/vector.isle line 30.
1588
0
                                                                returns.extend(Some(v1391));
1589
0
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
1590
0
                                                            }
1591
0
                                                        }
1592
0
                                                    }
1593
                                                }
1594
0
                                            }
1595
                                        }
1596
                                        &Opcode::Ineg => {
1597
519
                                            if v2.0 == v19.0 {
1598
519
                                                let v31 = constructor_isub(ctx, v2.0, v7.1, v30);
1599
                                                // Rule at src/opts/arithmetic.isle line 25.
1600
519
                                                returns.extend(Some(v31));
1601
519
                                                if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
1602
0
                                            }
1603
                                        }
1604
                                        &Opcode::Bnot => {
1605
195
                                            if v2.0 == v19.0 {
1606
195
                                                let mut v10 = C::inst_data_value_etor_returns::default();
1607
195
                                                C::inst_data_value_etor(ctx, v7.1, &mut v10);
1608
195
                                                let mut v10 = v10.into_context_iter();
1609
272
                                                while let Some(
v1177
) = v10.next(ctx) {
1610
                                                    if let &InstructionData::UnaryImm {
1611
0
                                                        opcode: ref v14,
1612
0
                                                        imm: v15,
1613
77
                                                    } = &v11.1 {
1614
0
                                                        if let &Opcode::Iconst = v14 {
1615
0
                                                            let v16 = C::u64_from_imm64(ctx, v15);
1616
0
                                                            if v16 == 0x1_u64 {
1617
0
                                                                if v2.0 == v11.0 {
1618
0
                                                                    let v65 = constructor_ineg(ctx, v2.0, v30);
1619
                                                                    // Rule at src/opts/arithmetic.isle line 68.
1620
0
                                                                    returns.extend(Some(v65));
1621
0
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
1622
0
                                                                }
1623
0
                                                            }
1624
0
                                                        }
1625
77
                                                    }
1626
                                                }
1627
0
                                            }
1628
                                        }
1629
4.43k
                                        _ => {}
1630
                                    }
1631
                                }
1632
                                &InstructionData::UnaryImm {
1633
736k
                                    opcode: ref v22,
1634
736k
                                    imm: v23,
1635
                                } => {
1636
736k
                                    if let &Opcode::Iconst = v22 {
1637
736k
                                        let v541 = C::fits_in_64(ctx, v2.0);
1638
736k
                                        if let Some(v542) = v541 {
1639
736k
                                            if v19.0 == v542 {
1640
736k
                                                let mut v10 = C::inst_data_value_etor_returns::default();
1641
736k
                                                C::inst_data_value_etor(ctx, v7.1, &mut v10);
1642
736k
                                                let mut v10 = v10.into_context_iter();
1643
1.47M
                                                while let Some(
v11736k
) = v10.next(ctx) {
1644
                                                    if let &InstructionData::UnaryImm {
1645
735k
                                                        opcode: ref v14,
1646
735k
                                                        imm: v15,
1647
736k
                                                    } = &v11.1 {
1648
735k
                                                        if let &Opcode::Iconst = v14 {
1649
735k
                                                            if v11.0 == v19.0 {
1650
735k
                                                                let v24 = C::u64_from_imm64(ctx, v23);
1651
735k
                                                                let v16 = C::u64_from_imm64(ctx, v15);
1652
735k
                                                                let v543 = C::u64_wrapping_add(ctx, v24, v16);
1653
735k
                                                                let v544 = C::imm64_masked(ctx, v542, v543);
1654
735k
                                                                let v545 = constructor_iconst(ctx, v542, v544);
1655
735k
                                                                let v546 = C::subsume(ctx, v545);
1656
                                                                // Rule at src/opts/cprop.isle line 2.
1657
735k
                                                                returns.extend(Some(v546));
1658
735k
                                                                if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
1659
0
                                                            }
1660
0
                                                        }
1661
664
                                                    }
1662
                                                }
1663
0
                                            }
1664
0
                                        }
1665
736k
                                        if v2.0 == v19.0 {
1666
736k
                                            let v607 = constructor_iadd(ctx, v2.0, v7.1, v7.0);
1667
                                            // Rule at src/opts/cprop.isle line 92.
1668
736k
                                            returns.extend(Some(v607));
1669
736k
                                            if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
1670
0
                                        }
1671
736k
                                        let v1142 = C::remat(ctx, arg0);
1672
                                        // Rule at src/opts/remat.isle line 3.
1673
736k
                                        returns.extend(Some(v1142));
1674
736k
                                        if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
1675
0
                                    }
1676
                                }
1677
937k
                                _ => {}
1678
                            }
1679
                        }
1680
2.69M
                        let mut v10 = C::inst_data_value_etor_returns::default();
1681
2.69M
                        C::inst_data_value_etor(ctx, v7.1, &mut v10);
1682
2.69M
                        let mut v10 = v10.into_context_iter();
1683
5.37M
                        while let Some(
v112.68M
) = v10.next(ctx) {
1684
2.68M
                            match &v11.1 {
1685
                                &InstructionData::Binary {
1686
121k
                                    opcode: ref v104,
1687
121k
                                    args: ref v105,
1688
                                } => {
1689
121k
                                    match v104 {
1690
                                        &Opcode::Iadd => {
1691
32.3k
                                            if v2.0 == v11.0 {
1692
32.3k
                                                let v106 = C::unpack_value_array_2(ctx, v105);
1693
32.3k
                                                let mut v109 = C::inst_data_value_etor_returns::default();
1694
32.3k
                                                C::inst_data_value_etor(ctx, v106.1, &mut v109);
1695
32.3k
                                                let mut v109 = v109.into_context_iter();
1696
68.7k
                                                while let Some(
v11036.3k
) = v109.next(ctx) {
1697
                                                    if let &InstructionData::Binary {
1698
14.3k
                                                        opcode: ref v113,
1699
14.3k
                                                        args: ref v114,
1700
36.3k
                                                    } = &v110.1 {
1701
14.3k
                                                        match v113 {
1702
                                                            &Opcode::Iadd => {
1703
12.6k
                                                                if v2.0 == v110.0 {
1704
12.6k
                                                                    let v118 = constructor_iadd(ctx, v2.0, v7.0, v106.0);
1705
12.6k
                                                                    let v115 = C::unpack_value_array_2(ctx, v114);
1706
12.6k
                                                                    let v119 = constructor_iadd(ctx, v2.0, v115.0, v115.1);
1707
12.6k
                                                                    let v120 = constructor_iadd(ctx, v2.0, v118, v119);
1708
12.6k
                                                                    let v121 = C::subsume(ctx, v120);
1709
                                                                    // Rule at src/opts/arithmetic.isle line 212.
1710
12.6k
                                                                    returns.extend(Some(v121));
1711
12.6k
                                                                    if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
1712
0
                                                                }
1713
                                                            }
1714
                                                            &Opcode::Isub => {
1715
122
                                                                if v2.0 == v110.0 {
1716
122
                                                                    let v118 = constructor_iadd(ctx, v2.0, v7.0, v106.0);
1717
122
                                                                    let v115 = C::unpack_value_array_2(ctx, v114);
1718
122
                                                                    let v165 = constructor_isub(ctx, v2.0, v115.0, v115.1);
1719
122
                                                                    let v178 = constructor_iadd(ctx, v2.0, v118, v165);
1720
122
                                                                    let v179 = C::subsume(ctx, v178);
1721
                                                                    // Rule at src/opts/arithmetic.isle line 260.
1722
122
                                                                    returns.extend(Some(v179));
1723
122
                                                                    if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
1724
0
                                                                }
1725
                                                            }
1726
1.60k
                                                            _ => {}
1727
                                                        }
1728
21.9k
                                                    }
1729
                                                }
1730
0
                                            }
1731
                                        }
1732
                                        &Opcode::Isub => {
1733
816
                                            if v2.0 == v11.0 {
1734
816
                                                let v106 = C::unpack_value_array_2(ctx, v105);
1735
816
                                                let mut v109 = C::inst_data_value_etor_returns::default();
1736
816
                                                C::inst_data_value_etor(ctx, v106.1, &mut v109);
1737
816
                                                let mut v109 = v109.into_context_iter();
1738
1.79k
                                                while let Some(
v110976
) = v109.next(ctx) {
1739
                                                    if let &InstructionData::Binary {
1740
235
                                                        opcode: ref v113,
1741
235
                                                        args: ref v114,
1742
976
                                                    } = &v110.1 {
1743
235
                                                        match v113 {
1744
                                                            &Opcode::Iadd => {
1745
43
                                                                if v2.0 == v110.0 {
1746
43
                                                                    let v118 = constructor_iadd(ctx, v2.0, v7.0, v106.0);
1747
43
                                                                    let v115 = C::unpack_value_array_2(ctx, v114);
1748
43
                                                                    let v119 = constructor_iadd(ctx, v2.0, v115.0, v115.1);
1749
43
                                                                    let v176 = constructor_isub(ctx, v2.0, v118, v119);
1750
43
                                                                    let v177 = C::subsume(ctx, v176);
1751
                                                                    // Rule at src/opts/arithmetic.isle line 256.
1752
43
                                                                    returns.extend(Some(v177));
1753
43
                                                                    if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
1754
0
                                                                }
1755
                                                            }
1756
                                                            &Opcode::Isub => {
1757
103
                                                                if v2.0 == v110.0 {
1758
103
                                                                    let v118 = constructor_iadd(ctx, v2.0, v7.0, v106.0);
1759
103
                                                                    let v115 = C::unpack_value_array_2(ctx, v114);
1760
103
                                                                    let v165 = constructor_isub(ctx, v2.0, v115.0, v115.1);
1761
103
                                                                    let v174 = constructor_isub(ctx, v2.0, v118, v165);
1762
103
                                                                    let v175 = C::subsume(ctx, v174);
1763
                                                                    // Rule at src/opts/arithmetic.isle line 252.
1764
103
                                                                    returns.extend(Some(v175));
1765
103
                                                                    if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
1766
0
                                                                }
1767
                                                            }
1768
89
                                                            _ => {}
1769
                                                        }
1770
741
                                                    }
1771
                                                }
1772
0
                                            }
1773
                                        }
1774
88.6k
                                        _ => {}
1775
                                    }
1776
                                }
1777
                                &InstructionData::Unary {
1778
545k
                                    opcode: ref v26,
1779
545k
                                    arg: v27,
1780
                                } => {
1781
545k
                                    if let &Opcode::Ineg = v26 {
1782
168
                                        if v2.0 == v11.0 {
1783
168
                                            let v28 = constructor_isub(ctx, v2.0, v7.0, v27);
1784
                                            // Rule at src/opts/arithmetic.isle line 23.
1785
168
                                            returns.extend(Some(v28));
1786
168
                                            if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
1787
0
                                        }
1788
545k
                                    }
1789
                                }
1790
                                &InstructionData::UnaryImm {
1791
1.99M
                                    opcode: ref v14,
1792
1.99M
                                    imm: v15,
1793
                                } => {
1794
1.99M
                                    if let &Opcode::Iconst = v14 {
1795
1.99M
                                        let v16 = C::u64_from_imm64(ctx, v15);
1796
1.99M
                                        if v16 == 0x0_u64 {
1797
23.6k
                                            if v2.0 == v11.0 {
1798
23.6k
                                                let v17 = C::subsume(ctx, v7.0);
1799
                                                // Rule at src/opts/arithmetic.isle line 7.
1800
23.6k
                                                returns.extend(Some(v17));
1801
23.6k
                                                if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
1802
0
                                            }
1803
1.97M
                                        }
1804
1.99M
                                        let v1142 = C::remat(ctx, arg0);
1805
                                        // Rule at src/opts/remat.isle line 5.
1806
1.99M
                                        returns.extend(Some(v1142));
1807
1.99M
                                        if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
1808
0
                                    }
1809
                                }
1810
16.5k
                                _ => {}
1811
                            }
1812
                        }
1813
                    }
1814
                    &Opcode::Isub => {
1815
61.8k
                        let v7 = C::unpack_value_array_2(ctx, v6);
1816
61.8k
                        let mut v10 = C::inst_data_value_etor_returns::default();
1817
61.8k
                        C::inst_data_value_etor(ctx, v7.1, &mut v10);
1818
61.8k
                        let mut v10 = v10.into_context_iter();
1819
120k
                        while let Some(
v1159.1k
) = v10.next(ctx) {
1820
59.1k
                            match &v11.1 {
1821
                                &InstructionData::Binary {
1822
12.5k
                                    opcode: ref v104,
1823
12.5k
                                    args: ref v105,
1824
                                } => {
1825
12.5k
                                    match v104 {
1826
                                        &Opcode::Iadd => {
1827
8.34k
                                            if v2.0 == v11.0 {
1828
8.34k
                                                let v106 = C::unpack_value_array_2(ctx, v105);
1829
8.34k
                                                let mut v109 = C::inst_data_value_etor_returns::default();
1830
8.34k
                                                C::inst_data_value_etor(ctx, v106.1, &mut v109);
1831
8.34k
                                                let mut v109 = v109.into_context_iter();
1832
16.7k
                                                while let Some(
v1108.41k
) = v109.next(ctx) {
1833
                                                    if let &InstructionData::Binary {
1834
274
                                                        opcode: ref v113,
1835
274
                                                        args: ref v114,
1836
8.41k
                                                    } = &v110.1 {
1837
274
                                                        match v113 {
1838
                                                            &Opcode::Iadd => {
1839
213
                                                                if v2.0 == v110.0 {
1840
213
                                                                    let v164 = constructor_isub(ctx, v2.0, v7.0, v106.0);
1841
213
                                                                    let v115 = C::unpack_value_array_2(ctx, v114);
1842
213
                                                                    let v119 = constructor_iadd(ctx, v2.0, v115.0, v115.1);
1843
213
                                                                    let v172 = constructor_isub(ctx, v2.0, v164, v119);
1844
213
                                                                    let v173 = C::subsume(ctx, v172);
1845
                                                                    // Rule at src/opts/arithmetic.isle line 248.
1846
213
                                                                    returns.extend(Some(v173));
1847
213
                                                                    if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
1848
0
                                                                }
1849
                                                            }
1850
                                                            &Opcode::Isub => {
1851
13
                                                                if v2.0 == v110.0 {
1852
13
                                                                    let v164 = constructor_isub(ctx, v2.0, v7.0, v106.0);
1853
13
                                                                    let v115 = C::unpack_value_array_2(ctx, v114);
1854
13
                                                                    let v165 = constructor_isub(ctx, v2.0, v115.0, v115.1);
1855
13
                                                                    let v170 = constructor_isub(ctx, v2.0, v164, v165);
1856
13
                                                                    let v171 = C::subsume(ctx, v170);
1857
                                                                    // Rule at src/opts/arithmetic.isle line 244.
1858
13
                                                                    returns.extend(Some(v171));
1859
13
                                                                    if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
1860
0
                                                                }
1861
                                                            }
1862
48
                                                            _ => {}
1863
                                                        }
1864
8.14k
                                                    }
1865
                                                }
1866
0
                                            }
1867
                                        }
1868
                                        &Opcode::Isub => {
1869
1.09k
                                            if v2.0 == v11.0 {
1870
1.09k
                                                let v106 = C::unpack_value_array_2(ctx, v105);
1871
1.09k
                                                let mut v109 = C::inst_data_value_etor_returns::default();
1872
1.09k
                                                C::inst_data_value_etor(ctx, v106.1, &mut v109);
1873
1.09k
                                                let mut v109 = v109.into_context_iter();
1874
2.52k
                                                while let Some(
v1101.42k
) = v109.next(ctx) {
1875
                                                    if let &InstructionData::Binary {
1876
139
                                                        opcode: ref v113,
1877
139
                                                        args: ref v114,
1878
1.42k
                                                    } = &v110.1 {
1879
139
                                                        match v113 {
1880
                                                            &Opcode::Iadd => {
1881
18
                                                                if v2.0 == v110.0 {
1882
18
                                                                    let v164 = constructor_isub(ctx, v2.0, v7.0, v106.0);
1883
18
                                                                    let v115 = C::unpack_value_array_2(ctx, v114);
1884
18
                                                                    let v119 = constructor_iadd(ctx, v2.0, v115.0, v115.1);
1885
18
                                                                    let v168 = constructor_iadd(ctx, v2.0, v164, v119);
1886
18
                                                                    let v169 = C::subsume(ctx, v168);
1887
                                                                    // Rule at src/opts/arithmetic.isle line 240.
1888
18
                                                                    returns.extend(Some(v169));
1889
18
                                                                    if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
1890
0
                                                                }
1891
                                                            }
1892
                                                            &Opcode::Isub => {
1893
56
                                                                if v2.0 == v110.0 {
1894
56
                                                                    let v164 = constructor_isub(ctx, v2.0, v7.0, v106.0);
1895
56
                                                                    let v115 = C::unpack_value_array_2(ctx, v114);
1896
56
                                                                    let v165 = constructor_isub(ctx, v2.0, v115.0, v115.1);
1897
56
                                                                    let v166 = constructor_iadd(ctx, v2.0, v164, v165);
1898
56
                                                                    let v167 = C::subsume(ctx, v166);
1899
                                                                    // Rule at src/opts/arithmetic.isle line 236.
1900
56
                                                                    returns.extend(Some(v167));
1901
56
                                                                    if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
1902
0
                                                                }
1903
                                                            }
1904
65
                                                            _ => {}
1905
                                                        }
1906
1.28k
                                                    }
1907
                                                }
1908
0
                                            }
1909
                                        }
1910
                                        &Opcode::Bor => {
1911
0
                                            if v2.0 == v11.0 {
1912
0
                                                let mut v18 = C::inst_data_value_etor_returns::default();
1913
0
                                                C::inst_data_value_etor(ctx, v7.0, &mut v18);
1914
0
                                                let mut v18 = v18.into_context_iter();
1915
0
                                                while let Some(v19) = v18.next(ctx) {
1916
                                                    if let &InstructionData::Binary {
1917
0
                                                        opcode: ref v122,
1918
0
                                                        args: ref v123,
1919
0
                                                    } = &v19.1 {
1920
0
                                                        if let &Opcode::Iadd = v122 {
1921
0
                                                            if v2.0 == v19.0 {
1922
0
                                                                let v106 = C::unpack_value_array_2(ctx, v105);
1923
0
                                                                let v124 = C::unpack_value_array_2(ctx, v123);
1924
0
                                                                if v106.0 == v124.0 {
1925
0
                                                                    if v106.1 == v124.1 {
1926
0
                                                                        let v230 = constructor_band(ctx, v2.0, v124.0, v124.1);
1927
                                                                        // Rule at src/opts/arithmetic.isle line 329.
1928
0
                                                                        returns.extend(Some(v230));
1929
0
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
1930
0
                                                                    }
1931
0
                                                                }
1932
0
                                                            }
1933
0
                                                        }
1934
0
                                                    }
1935
                                                }
1936
0
                                            }
1937
                                        }
1938
3.07k
                                        _ => {}
1939
                                    }
1940
                                }
1941
                                &InstructionData::Unary {
1942
2.35k
                                    opcode: ref v26,
1943
2.35k
                                    arg: v27,
1944
                                } => {
1945
2.35k
                                    match v26 {
1946
                                        &Opcode::Splat => {
1947
0
                                            if v2.0 == v11.0 {
1948
0
                                                let mut v18 = C::inst_data_value_etor_returns::default();
1949
0
                                                C::inst_data_value_etor(ctx, v7.0, &mut v18);
1950
0
                                                let mut v18 = v18.into_context_iter();
1951
0
                                                while let Some(v19) = v18.next(ctx) {
1952
                                                    if let &InstructionData::Unary {
1953
0
                                                        opcode: ref v29,
1954
0
                                                        arg: v30,
1955
0
                                                    } = &v19.1 {
1956
0
                                                        if let &Opcode::Splat = v29 {
1957
0
                                                            if v2.0 == v19.0 {
1958
0
                                                                let v1262 = C::lane_type(ctx, v2.0);
1959
0
                                                                let v1392 = constructor_isub(ctx, v1262, v30, v27);
1960
0
                                                                let v1393 = constructor_splat(ctx, v2.0, v1392);
1961
                                                                // Rule at src/opts/vector.isle line 33.
1962
0
                                                                returns.extend(Some(v1393));
1963
0
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
1964
0
                                                            }
1965
0
                                                        }
1966
0
                                                    }
1967
                                                }
1968
0
                                            }
1969
                                        }
1970
                                        &Opcode::Ineg => {
1971
83
                                            if v2.0 == v11.0 {
1972
83
                                                let v44 = constructor_iadd(ctx, v2.0, v7.0, v27);
1973
                                                // Rule at src/opts/arithmetic.isle line 30.
1974
83
                                                returns.extend(Some(v44));
1975
83
                                                if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
1976
0
                                            }
1977
                                        }
1978
2.27k
                                        _ => {}
1979
                                    }
1980
                                }
1981
                                &InstructionData::UnaryImm {
1982
34.3k
                                    opcode: ref v14,
1983
34.3k
                                    imm: v15,
1984
                                } => {
1985
34.3k
                                    if let &Opcode::Iconst = v14 {
1986
34.3k
                                        if v2.0 == v11.0 {
1987
34.3k
                                            let mut v18 = C::inst_data_value_etor_returns::default();
1988
34.3k
                                            C::inst_data_value_etor(ctx, v7.0, &mut v18);
1989
34.3k
                                            let mut v18 = v18.into_context_iter();
1990
68.1k
                                            while let Some(
v1933.7k
) = v18.next(ctx) {
1991
                                                if let &InstructionData::Binary {
1992
1.04k
                                                    opcode: ref v122,
1993
1.04k
                                                    args: ref v123,
1994
33.7k
                                                } = &v19.1 {
1995
1.04k
                                                    match v122 {
1996
                                                        &Opcode::Iadd => {
1997
382
                                                            if v2.0 == v19.0 {
1998
382
                                                                let v124 = C::unpack_value_array_2(ctx, v123);
1999
382
                                                                let mut v199 = C::inst_data_value_etor_returns::default();
2000
382
                                                                C::inst_data_value_etor(ctx, v124.1, &mut v199);
2001
382
                                                                let mut v199 = v199.into_context_iter();
2002
767
                                                                while let Some(
v200385
) = v199.next(ctx) {
2003
                                                                    if let &InstructionData::UnaryImm {
2004
290
                                                                        opcode: ref v241,
2005
290
                                                                        imm: v242,
2006
385
                                                                    } = &v200.1 {
2007
290
                                                                        if let &Opcode::Iconst = v241 {
2008
290
                                                                            if v2.0 == v200.0 {
2009
290
                                                                                let v16 = C::u64_from_imm64(ctx, v15);
2010
290
                                                                                let v243 = C::u64_from_imm64(ctx, v242);
2011
290
                                                                                let v629 = C::u64_wrapping_sub(ctx, v16, v243);
2012
290
                                                                                let v630 = C::imm64_masked(ctx, v2.0, v629);
2013
290
                                                                                let v631 = constructor_iconst(ctx, v2.0, v630);
2014
290
                                                                                let v632 = constructor_isub(ctx, v2.0, v124.0, v631);
2015
                                                                                // Rule at src/opts/cprop.isle line 141.
2016
290
                                                                                returns.extend(Some(v632));
2017
290
                                                                                if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
2018
0
                                                                            }
2019
0
                                                                        }
2020
95
                                                                    }
2021
                                                                }
2022
0
                                                            }
2023
                                                        }
2024
                                                        &Opcode::Isub => {
2025
111
                                                            if v2.0 == v19.0 {
2026
111
                                                                let v124 = C::unpack_value_array_2(ctx, v123);
2027
111
                                                                let mut v127 = C::inst_data_value_etor_returns::default();
2028
111
                                                                C::inst_data_value_etor(ctx, v124.0, &mut v127);
2029
111
                                                                let mut v127 = v127.into_context_iter();
2030
322
                                                                while let Some(
v128211
) = v127.next(ctx) {
2031
                                                                    if let &InstructionData::UnaryImm {
2032
0
                                                                        opcode: ref v622,
2033
0
                                                                        imm: v623,
2034
211
                                                                    } = &v128.1 {
2035
0
                                                                        if let &Opcode::Iconst = v622 {
2036
0
                                                                            if v2.0 == v128.0 {
2037
0
                                                                                let v624 = C::u64_from_imm64(ctx, v623);
2038
0
                                                                                let v16 = C::u64_from_imm64(ctx, v15);
2039
0
                                                                                let v625 = C::u64_wrapping_sub(ctx, v624, v16);
2040
0
                                                                                let v626 = C::imm64_masked(ctx, v2.0, v625);
2041
0
                                                                                let v627 = constructor_iconst(ctx, v2.0, v626);
2042
0
                                                                                let v628 = constructor_isub(ctx, v2.0, v627, v124.1);
2043
                                                                                // Rule at src/opts/cprop.isle line 137.
2044
0
                                                                                returns.extend(Some(v628));
2045
0
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
2046
0
                                                                            }
2047
0
                                                                        }
2048
211
                                                                    }
2049
                                                                }
2050
111
                                                                let mut v199 = C::inst_data_value_etor_returns::default();
2051
111
                                                                C::inst_data_value_etor(ctx, v124.1, &mut v199);
2052
111
                                                                let mut v199 = v199.into_context_iter();
2053
322
                                                                while let Some(
v200211
) = v199.next(ctx) {
2054
                                                                    if let &InstructionData::UnaryImm {
2055
2
                                                                        opcode: ref v241,
2056
2
                                                                        imm: v242,
2057
211
                                                                    } = &v200.1 {
2058
2
                                                                        if let &Opcode::Iconst = v241 {
2059
2
                                                                            if v2.0 == v200.0 {
2060
2
                                                                                let v243 = C::u64_from_imm64(ctx, v242);
2061
2
                                                                                let v16 = C::u64_from_imm64(ctx, v15);
2062
2
                                                                                let v618 = C::u64_wrapping_add(ctx, v243, v16);
2063
2
                                                                                let v619 = C::imm64_masked(ctx, v2.0, v618);
2064
2
                                                                                let v620 = constructor_iconst(ctx, v2.0, v619);
2065
2
                                                                                let v621 = constructor_isub(ctx, v2.0, v124.0, v620);
2066
                                                                                // Rule at src/opts/cprop.isle line 133.
2067
2
                                                                                returns.extend(Some(v621));
2068
2
                                                                                if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
2069
0
                                                                            }
2070
0
                                                                        }
2071
209
                                                                    }
2072
                                                                }
2073
0
                                                            }
2074
                                                        }
2075
552
                                                        _ => {}
2076
                                                    }
2077
32.7k
                                                }
2078
                                            }
2079
34.3k
                                            let v16 = C::u64_from_imm64(ctx, v15);
2080
34.3k
                                            if v16 == 0x0_u64 {
2081
4.52k
                                                let v17 = C::subsume(ctx, v7.0);
2082
                                                // Rule at src/opts/arithmetic.isle line 12.
2083
4.52k
                                                returns.extend(Some(v17));
2084
4.52k
                                                if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
2085
29.8k
                                            }
2086
0
                                        }
2087
34.3k
                                        let v541 = C::fits_in_64(ctx, v2.0);
2088
34.3k
                                        if let Some(v542) = v541 {
2089
34.3k
                                            if v11.0 == v542 {
2090
34.3k
                                                let mut v18 = C::inst_data_value_etor_returns::default();
2091
34.3k
                                                C::inst_data_value_etor(ctx, v7.0, &mut v18);
2092
34.3k
                                                let mut v18 = v18.into_context_iter();
2093
68.1k
                                                while let Some(
v1933.7k
) = v18.next(ctx) {
2094
                                                    if let &InstructionData::UnaryImm {
2095
15.9k
                                                        opcode: ref v22,
2096
15.9k
                                                        imm: v23,
2097
33.7k
                                                    } = &v19.1 {
2098
15.9k
                                                        if let &Opcode::Iconst = v22 {
2099
15.9k
                                                            if v11.0 == v19.0 {
2100
15.9k
                                                                let v24 = C::u64_from_imm64(ctx, v23);
2101
15.9k
                                                                let v16 = C::u64_from_imm64(ctx, v15);
2102
15.9k
                                                                let v547 = C::u64_wrapping_sub(ctx, v24, v16);
2103
15.9k
                                                                let v548 = C::imm64_masked(ctx, v542, v547);
2104
15.9k
                                                                let v549 = constructor_iconst(ctx, v542, v548);
2105
15.9k
                                                                let v550 = C::subsume(ctx, v549);
2106
                                                                // Rule at src/opts/cprop.isle line 8.
2107
15.9k
                                                                returns.extend(Some(v550));
2108
15.9k
                                                                if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
2109
0
                                                            }
2110
0
                                                        }
2111
17.7k
                                                    }
2112
                                                }
2113
0
                                            }
2114
0
                                        }
2115
34.3k
                                        let v1142 = C::remat(ctx, arg0);
2116
                                        // Rule at src/opts/remat.isle line 9.
2117
34.3k
                                        returns.extend(Some(v1142));
2118
34.3k
                                        if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
2119
0
                                    }
2120
                                }
2121
9.89k
                                _ => {}
2122
                            }
2123
                        }
2124
61.8k
                        let mut v18 = C::inst_data_value_etor_returns::default();
2125
61.8k
                        C::inst_data_value_etor(ctx, v7.0, &mut v18);
2126
61.8k
                        let mut v18 = v18.into_context_iter();
2127
119k
                        while let Some(
v1957.7k
) = v18.next(ctx) {
2128
57.7k
                            match &v19.1 {
2129
                                &InstructionData::Binary {
2130
5.56k
                                    opcode: ref v122,
2131
5.56k
                                    args: ref v123,
2132
                                } => {
2133
5.56k
                                    match v122 {
2134
                                        &Opcode::Iadd => {
2135
2.05k
                                            if v2.0 == v19.0 {
2136
2.05k
                                                let v124 = C::unpack_value_array_2(ctx, v123);
2137
2.05k
                                                let mut v127 = C::inst_data_value_etor_returns::default();
2138
2.05k
                                                C::inst_data_value_etor(ctx, v124.0, &mut v127);
2139
2.05k
                                                let mut v127 = v127.into_context_iter();
2140
3.29k
                                                while let Some(
v1281.24k
) = v127.next(ctx) {
2141
                                                    if let &InstructionData::Binary {
2142
217
                                                        opcode: ref v131,
2143
217
                                                        args: ref v132,
2144
1.24k
                                                    } = &v128.1 {
2145
217
                                                        match v131 {
2146
                                                            &Opcode::Iadd => {
2147
80
                                                                if v2.0 == v128.0 {
2148
80
                                                                    let v133 = C::unpack_value_array_2(ctx, v132);
2149
80
                                                                    let v136 = constructor_iadd(ctx, v2.0, v133.0, v133.1);
2150
80
                                                                    let v183 = constructor_isub(ctx, v2.0, v124.1, v7.1);
2151
80
                                                                    let v194 = constructor_iadd(ctx, v2.0, v136, v183);
2152
80
                                                                    let v195 = C::subsume(ctx, v194);
2153
                                                                    // Rule at src/opts/arithmetic.isle line 290.
2154
80
                                                                    returns.extend(Some(v195));
2155
80
                                                                    if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
2156
0
                                                                }
2157
                                                            }
2158
                                                            &Opcode::Isub => {
2159
45
                                                                if v2.0 == v128.0 {
2160
45
                                                                    let v133 = C::unpack_value_array_2(ctx, v132);
2161
45
                                                                    let v180 = constructor_isub(ctx, v2.0, v133.0, v133.1);
2162
45
                                                                    let v183 = constructor_isub(ctx, v2.0, v124.1, v7.1);
2163
45
                                                                    let v186 = constructor_iadd(ctx, v2.0, v180, v183);
2164
45
                                                                    let v187 = C::subsume(ctx, v186);
2165
                                                                    // Rule at src/opts/arithmetic.isle line 274.
2166
45
                                                                    returns.extend(Some(v187));
2167
45
                                                                    if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
2168
0
                                                                }
2169
                                                            }
2170
92
                                                            _ => {}
2171
                                                        }
2172
1.02k
                                                    }
2173
                                                }
2174
0
                                            }
2175
                                        }
2176
                                        &Opcode::Isub => {
2177
1.85k
                                            if v2.0 == v19.0 {
2178
1.85k
                                                let v124 = C::unpack_value_array_2(ctx, v123);
2179
1.85k
                                                let mut v127 = C::inst_data_value_etor_returns::default();
2180
1.85k
                                                C::inst_data_value_etor(ctx, v124.0, &mut v127);
2181
1.85k
                                                let mut v127 = v127.into_context_iter();
2182
3.48k
                                                while let Some(
v1281.63k
) = v127.next(ctx) {
2183
                                                    if let &InstructionData::Binary {
2184
409
                                                        opcode: ref v131,
2185
409
                                                        args: ref v132,
2186
1.63k
                                                    } = &v128.1 {
2187
409
                                                        match v131 {
2188
                                                            &Opcode::Iadd => {
2189
152
                                                                if v2.0 == v128.0 {
2190
152
                                                                    let v133 = C::unpack_value_array_2(ctx, v132);
2191
152
                                                                    let v136 = constructor_iadd(ctx, v2.0, v133.0, v133.1);
2192
152
                                                                    let v137 = constructor_iadd(ctx, v2.0, v124.1, v7.1);
2193
152
                                                                    let v190 = constructor_isub(ctx, v2.0, v136, v137);
2194
152
                                                                    let v191 = C::subsume(ctx, v190);
2195
                                                                    // Rule at src/opts/arithmetic.isle line 282.
2196
152
                                                                    returns.extend(Some(v191));
2197
152
                                                                    if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
2198
0
                                                                }
2199
                                                            }
2200
                                                            &Opcode::Isub => {
2201
251
                                                                if v2.0 == v128.0 {
2202
251
                                                                    let v133 = C::unpack_value_array_2(ctx, v132);
2203
251
                                                                    let v180 = constructor_isub(ctx, v2.0, v133.0, v133.1);
2204
251
                                                                    let v137 = constructor_iadd(ctx, v2.0, v124.1, v7.1);
2205
251
                                                                    let v181 = constructor_isub(ctx, v2.0, v180, v137);
2206
251
                                                                    let v182 = C::subsume(ctx, v181);
2207
                                                                    // Rule at src/opts/arithmetic.isle line 266.
2208
251
                                                                    returns.extend(Some(v182));
2209
251
                                                                    if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
2210
0
                                                                }
2211
                                                            }
2212
6
                                                            _ => {}
2213
                                                        }
2214
1.22k
                                                    }
2215
                                                }
2216
0
                                            }
2217
                                        }
2218
1.65k
                                        _ => {}
2219
                                    }
2220
                                }
2221
                                &InstructionData::UnaryImm {
2222
20.6k
                                    opcode: ref v22,
2223
20.6k
                                    imm: v23,
2224
                                } => {
2225
20.6k
                                    if let &Opcode::Iconst = v22 {
2226
20.6k
                                        if v2.0 == v19.0 {
2227
20.6k
                                            let v24 = C::u64_from_imm64(ctx, v23);
2228
20.6k
                                            if v24 == 0x0_u64 {
2229
6.34k
                                                let v25 = constructor_ineg(ctx, v2.0, v7.1);
2230
                                                // Rule at src/opts/arithmetic.isle line 17.
2231
6.34k
                                                returns.extend(Some(v25));
2232
6.34k
                                                if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
2233
14.3k
                                            }
2234
20.6k
                                            let v608 = constructor_isub(ctx, v2.0, v7.1, v7.0);
2235
20.6k
                                            let v609 = constructor_ineg(ctx, v2.0, v608);
2236
                                            // Rule at src/opts/cprop.isle line 97.
2237
20.6k
                                            returns.extend(Some(v609));
2238
20.6k
                                            if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
2239
0
                                        }
2240
20.6k
                                        let v1142 = C::remat(ctx, arg0);
2241
                                        // Rule at src/opts/remat.isle line 7.
2242
20.6k
                                        returns.extend(Some(v1142));
2243
20.6k
                                        if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
2244
0
                                    }
2245
                                }
2246
31.5k
                                _ => {}
2247
                            }
2248
                        }
2249
61.8k
                        if v7.0 == v7.1 {
2250
334
                            let v52 = C::ty_int(ctx, v2.0);
2251
334
                            if let Some(v53) = v52 {
2252
334
                                let v55 = constructor_iconst_u(ctx, v53, 0x0_u64);
2253
334
                                let v56 = C::subsume(ctx, v55);
2254
                                // Rule at src/opts/arithmetic.isle line 49.
2255
334
                                returns.extend(Some(v56));
2256
334
                                if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
2257
0
                            }
2258
61.4k
                        }
2259
61.8k
                        let mut v58 = C::inst_data_value_tupled_etor_returns::default();
2260
61.8k
                        C::inst_data_value_tupled_etor(ctx, v7.1, &mut v58);
2261
61.8k
                        let mut v58 = v58.into_context_iter();
2262
120k
                        while let Some(
v5959.1k
) = v58.next(ctx) {
2263
59.1k
                            let v60 = C::iconst_sextend_etor(ctx, v59);
2264
59.1k
                            if let Some(
v6134.3k
) = v60 {
2265
34.3k
                                let v685 = C::i64_wrapping_neg(ctx, v61.1);
2266
34.3k
                                let v686 = C::i64_cast_unsigned(ctx, v685);
2267
34.3k
                                let v687 = C::i64_cast_unsigned(ctx, v61.1);
2268
34.3k
                                let v688 = C::u64_lt(ctx, v686, v687);
2269
34.3k
                                if v688 == true {
2270
6.11k
                                    if v2.0 == v61.0 {
2271
6.11k
                                        let v689 = C::imm64_masked(ctx, v2.0, v686);
2272
6.11k
                                        let v690 = constructor_iconst(ctx, v2.0, v689);
2273
6.11k
                                        let v691 = constructor_iadd(ctx, v2.0, v7.0, v690);
2274
                                        // Rule at src/opts/cprop.isle line 196.
2275
6.11k
                                        returns.extend(Some(v691));
2276
6.11k
                                        if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
2277
0
                                    }
2278
28.2k
                                }
2279
24.7k
                            }
2280
                        }
2281
                    }
2282
                    &Opcode::Imul => {
2283
58.8k
                        let v7 = C::unpack_value_array_2(ctx, v6);
2284
58.8k
                        let mut v10 = C::inst_data_value_etor_returns::default();
2285
58.8k
                        C::inst_data_value_etor(ctx, v7.1, &mut v10);
2286
58.8k
                        let mut v10 = v10.into_context_iter();
2287
117k
                        while let Some(
v1158.5k
) = v10.next(ctx) {
2288
58.5k
                            match &v11.1 {
2289
                                &InstructionData::Binary {
2290
228
                                    opcode: ref v104,
2291
228
                                    args: ref v105,
2292
                                } => {
2293
228
                                    if let &Opcode::Imul = v104 {
2294
1
                                        if v2.0 == v11.0 {
2295
1
                                            let v106 = C::unpack_value_array_2(ctx, v105);
2296
1
                                            let mut v109 = C::inst_data_value_etor_returns::default();
2297
1
                                            C::inst_data_value_etor(ctx, v106.1, &mut v109);
2298
1
                                            let mut v109 = v109.into_context_iter();
2299
1
                                            while let Some(
v1100
) = v109.next(ctx) {
2300
0
                                                match &v110.1 {
2301
                                                    &InstructionData::Binary {
2302
0
                                                        opcode: ref v113,
2303
0
                                                        args: ref v114,
2304
                                                    } => {
2305
0
                                                        if let &Opcode::Imul = v113 {
2306
0
                                                            if v2.0 == v110.0 {
2307
0
                                                                let v140 = constructor_imul(ctx, v2.0, v7.0, v106.0);
2308
0
                                                                let v115 = C::unpack_value_array_2(ctx, v114);
2309
0
                                                                let v141 = constructor_imul(ctx, v2.0, v115.0, v115.1);
2310
0
                                                                let v142 = constructor_imul(ctx, v2.0, v140, v141);
2311
0
                                                                let v143 = C::subsume(ctx, v142);
2312
                                                                // Rule at src/opts/arithmetic.isle line 217.
2313
0
                                                                returns.extend(Some(v143));
2314
0
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
2315
0
                                                            }
2316
0
                                                        }
2317
                                                    }
2318
                                                    &InstructionData::UnaryImm {
2319
0
                                                        opcode: ref v724,
2320
0
                                                        imm: v725,
2321
                                                    } => {
2322
0
                                                        if let &Opcode::Iconst = v724 {
2323
0
                                                            let mut v18 = C::inst_data_value_etor_returns::default();
2324
0
                                                            C::inst_data_value_etor(ctx, v7.0, &mut v18);
2325
0
                                                            let mut v18 = v18.into_context_iter();
2326
0
                                                            while let Some(v19) = v18.next(ctx) {
2327
                                                                if let &InstructionData::Binary {
2328
0
                                                                    opcode: ref v122,
2329
0
                                                                    args: ref v123,
2330
0
                                                                } = &v19.1 {
2331
0
                                                                    if let &Opcode::Imul = v122 {
2332
0
                                                                        if v2.0 == v19.0 {
2333
0
                                                                            let v124 = C::unpack_value_array_2(ctx, v123);
2334
0
                                                                            let mut v199 = C::inst_data_value_etor_returns::default();
2335
0
                                                                            C::inst_data_value_etor(ctx, v124.1, &mut v199);
2336
0
                                                                            let mut v199 = v199.into_context_iter();
2337
0
                                                                            while let Some(v200) = v199.next(ctx) {
2338
                                                                                if let &InstructionData::UnaryImm {
2339
0
                                                                                    opcode: ref v241,
2340
0
                                                                                    imm: v242,
2341
0
                                                                                } = &v200.1 {
2342
0
                                                                                    if let &Opcode::Iconst = v241 {
2343
0
                                                                                        let v729 = constructor_imul(ctx, v2.0, v124.0, v106.0);
2344
0
                                                                                        let v730 = constructor_imul(ctx, v2.0, v124.1, v106.1);
2345
0
                                                                                        let v731 = constructor_imul(ctx, v2.0, v729, v730);
2346
                                                                                        // Rule at src/opts/cprop.isle line 245.
2347
0
                                                                                        returns.extend(Some(v731));
2348
0
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
2349
0
                                                                                    }
2350
0
                                                                                }
2351
                                                                            }
2352
0
                                                                        }
2353
0
                                                                    }
2354
0
                                                                }
2355
                                                            }
2356
0
                                                        }
2357
                                                    }
2358
0
                                                    _ => {}
2359
                                                }
2360
                                            }
2361
0
                                        }
2362
227
                                    }
2363
                                }
2364
                                &InstructionData::Unary {
2365
80
                                    opcode: ref v26,
2366
80
                                    arg: v27,
2367
                                } => {
2368
80
                                    match v26 {
2369
                                        &Opcode::Splat => {
2370
0
                                            if v2.0 == v11.0 {
2371
0
                                                let mut v18 = C::inst_data_value_etor_returns::default();
2372
0
                                                C::inst_data_value_etor(ctx, v7.0, &mut v18);
2373
0
                                                let mut v18 = v18.into_context_iter();
2374
0
                                                while let Some(v19) = v18.next(ctx) {
2375
                                                    if let &InstructionData::Unary {
2376
0
                                                        opcode: ref v29,
2377
0
                                                        arg: v30,
2378
0
                                                    } = &v19.1 {
2379
0
                                                        if let &Opcode::Splat = v29 {
2380
0
                                                            if v2.0 == v19.0 {
2381
0
                                                                let v1262 = C::lane_type(ctx, v2.0);
2382
0
                                                                let v1394 = constructor_imul(ctx, v1262, v30, v27);
2383
0
                                                                let v1395 = constructor_splat(ctx, v2.0, v1394);
2384
                                                                // Rule at src/opts/vector.isle line 36.
2385
0
                                                                returns.extend(Some(v1395));
2386
0
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
2387
0
                                                            }
2388
0
                                                        }
2389
0
                                                    }
2390
                                                }
2391
0
                                            }
2392
                                        }
2393
                                        &Opcode::Ineg => {
2394
0
                                            if v2.0 == v11.0 {
2395
0
                                                let mut v18 = C::inst_data_value_etor_returns::default();
2396
0
                                                C::inst_data_value_etor(ctx, v7.0, &mut v18);
2397
0
                                                let mut v18 = v18.into_context_iter();
2398
0
                                                while let Some(v19) = v18.next(ctx) {
2399
                                                    if let &InstructionData::Unary {
2400
0
                                                        opcode: ref v29,
2401
0
                                                        arg: v30,
2402
0
                                                    } = &v19.1 {
2403
0
                                                        if let &Opcode::Ineg = v29 {
2404
0
                                                            if v2.0 == v19.0 {
2405
0
                                                                let v48 = constructor_imul(ctx, v2.0, v30, v27);
2406
0
                                                                let v49 = C::subsume(ctx, v48);
2407
                                                                // Rule at src/opts/arithmetic.isle line 37.
2408
0
                                                                returns.extend(Some(v49));
2409
0
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
2410
0
                                                            }
2411
0
                                                        }
2412
0
                                                    }
2413
                                                }
2414
0
                                            }
2415
                                        }
2416
80
                                        _ => {}
2417
                                    }
2418
                                }
2419
                                &InstructionData::UnaryImm {
2420
57.9k
                                    opcode: ref v14,
2421
57.9k
                                    imm: v15,
2422
                                } => {
2423
57.9k
                                    if let &Opcode::Iconst = v14 {
2424
57.9k
                                        let v16 = C::u64_from_imm64(ctx, v15);
2425
57.9k
                                        match v16 {
2426
                                            0x0_u64 => {
2427
6
                                                if v2.0 == v11.0 {
2428
6
                                                    let v57 = C::subsume(ctx, v7.1);
2429
                                                    // Rule at src/opts/arithmetic.isle line 58.
2430
6
                                                    returns.extend(Some(v57));
2431
6
                                                    if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
2432
0
                                                }
2433
                                            }
2434
                                            0x1_u64 => {
2435
0
                                                if v2.0 == v11.0 {
2436
0
                                                    let v17 = C::subsume(ctx, v7.0);
2437
                                                    // Rule at src/opts/arithmetic.isle line 52.
2438
0
                                                    returns.extend(Some(v17));
2439
0
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
2440
0
                                                }
2441
                                            }
2442
                                            0x2_u64 => {
2443
0
                                                let v73 = constructor_iadd(ctx, v2.0, v7.0, v7.0);
2444
                                                // Rule at src/opts/arithmetic.isle line 168.
2445
0
                                                returns.extend(Some(v73));
2446
0
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
2447
                                            }
2448
57.9k
                                            _ => {}
2449
                                        }
2450
57.9k
                                        let mut v18 = C::inst_data_value_etor_returns::default();
2451
57.9k
                                        C::inst_data_value_etor(ctx, v7.0, &mut v18);
2452
57.9k
                                        let mut v18 = v18.into_context_iter();
2453
96.4k
                                        while let Some(
v1938.4k
) = v18.next(ctx) {
2454
38.4k
                                            match &v19.1 {
2455
                                                &InstructionData::Binary {
2456
5.19k
                                                    opcode: ref v122,
2457
5.19k
                                                    args: ref v123,
2458
                                                } => {
2459
5.19k
                                                    if let &Opcode::Imul = v122 {
2460
0
                                                        if v2.0 == v11.0 {
2461
0
                                                            if v2.0 == v19.0 {
2462
0
                                                                let v124 = C::unpack_value_array_2(ctx, v123);
2463
0
                                                                let mut v199 = C::inst_data_value_etor_returns::default();
2464
0
                                                                C::inst_data_value_etor(ctx, v124.1, &mut v199);
2465
0
                                                                let mut v199 = v199.into_context_iter();
2466
0
                                                                while let Some(v200) = v199.next(ctx) {
2467
                                                                    if let &InstructionData::UnaryImm {
2468
0
                                                                        opcode: ref v241,
2469
0
                                                                        imm: v242,
2470
0
                                                                    } = &v200.1 {
2471
0
                                                                        if let &Opcode::Iconst = v241 {
2472
0
                                                                            if v2.0 == v200.0 {
2473
0
                                                                                let v638 = constructor_imul(ctx, v2.0, v124.1, v7.1);
2474
0
                                                                                let v639 = constructor_imul(ctx, v2.0, v124.0, v638);
2475
                                                                                // Rule at src/opts/cprop.isle line 154.
2476
0
                                                                                returns.extend(Some(v639));
2477
0
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
2478
0
                                                                            }
2479
0
                                                                        }
2480
0
                                                                    }
2481
                                                                }
2482
0
                                                            }
2483
0
                                                        }
2484
5.19k
                                                    }
2485
                                                }
2486
                                                &InstructionData::UnaryImm {
2487
12
                                                    opcode: ref v22,
2488
12
                                                    imm: v23,
2489
                                                } => {
2490
12
                                                    if let &Opcode::Iconst = v22 {
2491
12
                                                        let v541 = C::fits_in_64(ctx, v2.0);
2492
12
                                                        if let Some(v542) = v541 {
2493
12
                                                            if v11.0 == v19.0 {
2494
12
                                                                if v11.0 == v542 {
2495
12
                                                                    let v24 = C::u64_from_imm64(ctx, v23);
2496
12
                                                                    let v551 = C::u64_wrapping_mul(ctx, v24, v16);
2497
12
                                                                    let v552 = C::imm64_masked(ctx, v542, v551);
2498
12
                                                                    let v553 = constructor_iconst(ctx, v542, v552);
2499
12
                                                                    let v554 = C::subsume(ctx, v553);
2500
                                                                    // Rule at src/opts/cprop.isle line 14.
2501
12
                                                                    returns.extend(Some(v554));
2502
12
                                                                    if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
2503
0
                                                                }
2504
0
                                                            }
2505
0
                                                        }
2506
0
                                                    }
2507
                                                }
2508
33.2k
                                                _ => {}
2509
                                            }
2510
                                        }
2511
57.9k
                                        let v74 = C::imm64_power_of_two(ctx, v15);
2512
57.9k
                                        if let Some(
v750
) = v74 {
2513
0
                                            let v76 = C::imm64(ctx, v75);
2514
0
                                            let v77 = constructor_iconst(ctx, v2.0, v76);
2515
0
                                            let v78 = constructor_ishl(ctx, v2.0, v7.0, v77);
2516
                                            // Rule at src/opts/arithmetic.isle line 176.
2517
0
                                            returns.extend(Some(v78));
2518
0
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
2519
57.9k
                                        }
2520
0
                                    }
2521
                                }
2522
297
                                _ => {}
2523
                            }
2524
                        }
2525
58.8k
                        let mut v18 = C::inst_data_value_etor_returns::default();
2526
58.8k
                        C::inst_data_value_etor(ctx, v7.0, &mut v18);
2527
58.8k
                        let mut v18 = v18.into_context_iter();
2528
98.0k
                        while let Some(
v1939.2k
) = v18.next(ctx) {
2529
39.2k
                            match &v19.1 {
2530
                                &InstructionData::Binary {
2531
5.55k
                                    opcode: ref v122,
2532
5.55k
                                    args: ref v123,
2533
                                } => {
2534
5.55k
                                    if let &Opcode::Imul = v122 {
2535
1
                                        if v2.0 == v19.0 {
2536
1
                                            let v124 = C::unpack_value_array_2(ctx, v123);
2537
1
                                            let mut v127 = C::inst_data_value_etor_returns::default();
2538
1
                                            C::inst_data_value_etor(ctx, v124.0, &mut v127);
2539
1
                                            let mut v127 = v127.into_context_iter();
2540
2
                                            while let Some(
v1281
) = v127.next(ctx) {
2541
                                                if let &InstructionData::Binary {
2542
0
                                                    opcode: ref v131,
2543
0
                                                    args: ref v132,
2544
1
                                                } = &v128.1 {
2545
0
                                                    if let &Opcode::Imul = v131 {
2546
0
                                                        if v2.0 == v128.0 {
2547
0
                                                            let v133 = C::unpack_value_array_2(ctx, v132);
2548
0
                                                            let v144 = constructor_imul(ctx, v2.0, v133.0, v133.1);
2549
0
                                                            let v145 = constructor_imul(ctx, v2.0, v124.1, v7.1);
2550
0
                                                            let v146 = constructor_imul(ctx, v2.0, v144, v145);
2551
0
                                                            let v147 = C::subsume(ctx, v146);
2552
                                                            // Rule at src/opts/arithmetic.isle line 219.
2553
0
                                                            returns.extend(Some(v147));
2554
0
                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
2555
0
                                                        }
2556
0
                                                    }
2557
1
                                                }
2558
                                            }
2559
0
                                        }
2560
5.55k
                                    }
2561
                                }
2562
                                &InstructionData::UnaryImm {
2563
12
                                    opcode: ref v22,
2564
12
                                    imm: v23,
2565
                                } => {
2566
12
                                    if let &Opcode::Iconst = v22 {
2567
12
                                        let v79 = C::imm64_power_of_two(ctx, v23);
2568
12
                                        if let Some(
v800
) = v79 {
2569
0
                                            let v81 = C::imm64(ctx, v80);
2570
0
                                            let v82 = constructor_iconst(ctx, v2.0, v81);
2571
0
                                            let v83 = constructor_ishl(ctx, v2.0, v7.1, v82);
2572
                                            // Rule at src/opts/arithmetic.isle line 178.
2573
0
                                            returns.extend(Some(v83));
2574
0
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
2575
12
                                        }
2576
12
                                        if v2.0 == v19.0 {
2577
12
                                            let v610 = constructor_imul(ctx, v2.0, v7.1, v7.0);
2578
                                            // Rule at src/opts/cprop.isle line 100.
2579
12
                                            returns.extend(Some(v610));
2580
12
                                            if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
2581
0
                                        }
2582
0
                                    }
2583
                                }
2584
33.6k
                                _ => {}
2585
                            }
2586
                        }
2587
58.8k
                        let mut v58 = C::inst_data_value_tupled_etor_returns::default();
2588
58.8k
                        C::inst_data_value_tupled_etor(ctx, v7.1, &mut v58);
2589
58.8k
                        let mut v58 = v58.into_context_iter();
2590
117k
                        while let Some(
v5958.5k
) = v58.next(ctx) {
2591
58.5k
                            let v60 = C::iconst_sextend_etor(ctx, v59);
2592
58.5k
                            if let Some(
v6157.9k
) = v60 {
2593
57.9k
                                if v61.1 == -1_i64 {
2594
0
                                    if v2.0 == v61.0 {
2595
0
                                        let v64 = constructor_ineg(ctx, v2.0, v7.0);
2596
                                        // Rule at src/opts/arithmetic.isle line 64.
2597
0
                                        returns.extend(Some(v64));
2598
0
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
2599
0
                                    }
2600
57.9k
                                }
2601
605
                            }
2602
                        }
2603
                    }
2604
                    &Opcode::Umulhi => {
2605
3.00k
                        let v7 = C::unpack_value_array_2(ctx, v6);
2606
3.00k
                        let mut v10 = C::inst_data_value_etor_returns::default();
2607
3.00k
                        C::inst_data_value_etor(ctx, v7.1, &mut v10);
2608
3.00k
                        let mut v10 = v10.into_context_iter();
2609
6.01k
                        while let Some(
v113.00k
) = v10.next(ctx) {
2610
                            if let &InstructionData::Unary {
2611
0
                                opcode: ref v26,
2612
0
                                arg: v27,
2613
3.00k
                            } = &v11.1 {
2614
0
                                if let &Opcode::Splat = v26 {
2615
0
                                    if v2.0 == v11.0 {
2616
0
                                        let mut v18 = C::inst_data_value_etor_returns::default();
2617
0
                                        C::inst_data_value_etor(ctx, v7.0, &mut v18);
2618
0
                                        let mut v18 = v18.into_context_iter();
2619
0
                                        while let Some(v19) = v18.next(ctx) {
2620
                                            if let &InstructionData::Unary {
2621
0
                                                opcode: ref v29,
2622
0
                                                arg: v30,
2623
0
                                            } = &v19.1 {
2624
0
                                                if let &Opcode::Splat = v29 {
2625
0
                                                    if v2.0 == v19.0 {
2626
0
                                                        let v1262 = C::lane_type(ctx, v2.0);
2627
0
                                                        let v1398 = constructor_umulhi(ctx, v1262, v30, v27);
2628
0
                                                        let v1399 = constructor_splat(ctx, v2.0, v1398);
2629
                                                        // Rule at src/opts/vector.isle line 42.
2630
0
                                                        returns.extend(Some(v1399));
2631
0
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
2632
0
                                                    }
2633
0
                                                }
2634
0
                                            }
2635
                                        }
2636
0
                                    }
2637
0
                                }
2638
3.00k
                            }
2639
                        }
2640
                    }
2641
                    &Opcode::Smulhi => {
2642
454
                        let v7 = C::unpack_value_array_2(ctx, v6);
2643
454
                        let mut v10 = C::inst_data_value_etor_returns::default();
2644
454
                        C::inst_data_value_etor(ctx, v7.1, &mut v10);
2645
454
                        let mut v10 = v10.into_context_iter();
2646
908
                        while let Some(
v11454
) = v10.next(ctx) {
2647
                            if let &InstructionData::Unary {
2648
0
                                opcode: ref v26,
2649
0
                                arg: v27,
2650
454
                            } = &v11.1 {
2651
0
                                if let &Opcode::Splat = v26 {
2652
0
                                    if v2.0 == v11.0 {
2653
0
                                        let mut v18 = C::inst_data_value_etor_returns::default();
2654
0
                                        C::inst_data_value_etor(ctx, v7.0, &mut v18);
2655
0
                                        let mut v18 = v18.into_context_iter();
2656
0
                                        while let Some(v19) = v18.next(ctx) {
2657
                                            if let &InstructionData::Unary {
2658
0
                                                opcode: ref v29,
2659
0
                                                arg: v30,
2660
0
                                            } = &v19.1 {
2661
0
                                                if let &Opcode::Splat = v29 {
2662
0
                                                    if v2.0 == v19.0 {
2663
0
                                                        let v1262 = C::lane_type(ctx, v2.0);
2664
0
                                                        let v1396 = constructor_smulhi(ctx, v1262, v30, v27);
2665
0
                                                        let v1397 = constructor_splat(ctx, v2.0, v1396);
2666
                                                        // Rule at src/opts/vector.isle line 39.
2667
0
                                                        returns.extend(Some(v1397));
2668
0
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
2669
0
                                                    }
2670
0
                                                }
2671
0
                                            }
2672
                                        }
2673
0
                                    }
2674
0
                                }
2675
454
                            }
2676
                        }
2677
                    }
2678
                    &Opcode::Band => {
2679
61.6k
                        let v7 = C::unpack_value_array_2(ctx, v6);
2680
61.6k
                        let mut v10 = C::inst_data_value_etor_returns::default();
2681
61.6k
                        C::inst_data_value_etor(ctx, v7.1, &mut v10);
2682
61.6k
                        let mut v10 = v10.into_context_iter();
2683
125k
                        while let Some(
v1163.8k
) = v10.next(ctx) {
2684
63.8k
                            match &v11.1 {
2685
                                &InstructionData::Binary {
2686
4.28k
                                    opcode: ref v104,
2687
4.28k
                                    args: ref v105,
2688
                                } => {
2689
4.28k
                                    if let &Opcode::Band = v104 {
2690
3.44k
                                        if v2.0 == v11.0 {
2691
3.44k
                                            let v106 = C::unpack_value_array_2(ctx, v105);
2692
3.44k
                                            let mut v109 = C::inst_data_value_etor_returns::default();
2693
3.44k
                                            C::inst_data_value_etor(ctx, v106.1, &mut v109);
2694
3.44k
                                            let mut v109 = v109.into_context_iter();
2695
7.79k
                                            while let Some(
v1104.35k
) = v109.next(ctx) {
2696
4.35k
                                                match &v110.1 {
2697
                                                    &InstructionData::Binary {
2698
1.68k
                                                        opcode: ref v113,
2699
1.68k
                                                        args: ref v114,
2700
                                                    } => {
2701
1.68k
                                                        if let &Opcode::Band = v113 {
2702
1.56k
                                                            if v2.0 == v110.0 {
2703
1.56k
                                                                let v148 = constructor_band(ctx, v2.0, v7.0, v106.0);
2704
1.56k
                                                                let v115 = C::unpack_value_array_2(ctx, v114);
2705
1.56k
                                                                let v149 = constructor_band(ctx, v2.0, v115.0, v115.1);
2706
1.56k
                                                                let v150 = constructor_band(ctx, v2.0, v148, v149);
2707
1.56k
                                                                let v151 = C::subsume(ctx, v150);
2708
                                                                // Rule at src/opts/arithmetic.isle line 222.
2709
1.56k
                                                                returns.extend(Some(v151));
2710
1.56k
                                                                if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
2711
0
                                                            }
2712
120
                                                        }
2713
                                                    }
2714
                                                    &InstructionData::UnaryImm {
2715
10
                                                        opcode: ref v724,
2716
10
                                                        imm: v725,
2717
                                                    } => {
2718
10
                                                        if let &Opcode::Iconst = v724 {
2719
10
                                                            let mut v18 = C::inst_data_value_etor_returns::default();
2720
10
                                                            C::inst_data_value_etor(ctx, v7.0, &mut v18);
2721
10
                                                            let mut v18 = v18.into_context_iter();
2722
20
                                                            while let Some(
v1910
) = v18.next(ctx) {
2723
                                                                if let &InstructionData::Binary {
2724
7
                                                                    opcode: ref v122,
2725
7
                                                                    args: ref v123,
2726
10
                                                                } = &v19.1 {
2727
7
                                                                    if let &Opcode::Band = v122 {
2728
4
                                                                        if v2.0 == v19.0 {
2729
4
                                                                            let v124 = C::unpack_value_array_2(ctx, v123);
2730
4
                                                                            let mut v199 = C::inst_data_value_etor_returns::default();
2731
4
                                                                            C::inst_data_value_etor(ctx, v124.1, &mut v199);
2732
4
                                                                            let mut v199 = v199.into_context_iter();
2733
8
                                                                            while let Some(
v2004
) = v199.next(ctx) {
2734
                                                                                if let &InstructionData::UnaryImm {
2735
0
                                                                                    opcode: ref v241,
2736
0
                                                                                    imm: v242,
2737
4
                                                                                } = &v200.1 {
2738
0
                                                                                    if let &Opcode::Iconst = v241 {
2739
0
                                                                                        let v732 = constructor_band(ctx, v2.0, v124.0, v106.0);
2740
0
                                                                                        let v733 = constructor_band(ctx, v2.0, v124.1, v106.1);
2741
0
                                                                                        let v734 = constructor_band(ctx, v2.0, v732, v733);
2742
                                                                                        // Rule at src/opts/cprop.isle line 249.
2743
0
                                                                                        returns.extend(Some(v734));
2744
0
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
2745
0
                                                                                    }
2746
4
                                                                                }
2747
                                                                            }
2748
0
                                                                        }
2749
3
                                                                    }
2750
3
                                                                }
2751
                                                            }
2752
0
                                                        }
2753
                                                    }
2754
2.65k
                                                    _ => {}
2755
                                                }
2756
                                            }
2757
0
                                        }
2758
843
                                    }
2759
                                }
2760
                                &InstructionData::IntCompare {
2761
1.30k
                                    opcode: ref v1077,
2762
1.30k
                                    args: ref v1078,
2763
1.30k
                                    cond: ref v1079,
2764
                                } => {
2765
1.30k
                                    if let &Opcode::Icmp = v1077 {
2766
1.30k
                                        let v541 = C::fits_in_64(ctx, v2.0);
2767
1.30k
                                        if let Some(v542) = v541 {
2768
1.30k
                                            if v11.0 == v542 {
2769
1.30k
                                                let mut v18 = C::inst_data_value_etor_returns::default();
2770
1.30k
                                                C::inst_data_value_etor(ctx, v7.0, &mut v18);
2771
1.30k
                                                let mut v18 = v18.into_context_iter();
2772
2.61k
                                                while let Some(
v191.30k
) = v18.next(ctx) {
2773
                                                    if let &InstructionData::IntCompare {
2774
778
                                                        opcode: ref v1047,
2775
778
                                                        args: ref v1048,
2776
778
                                                        cond: ref v1049,
2777
1.30k
                                                    } = &v19.1 {
2778
778
                                                        if let &Opcode::Icmp = v1047 {
2779
778
                                                            let v1083 = constructor_intcc_comparable(ctx, v1049, v1079);
2780
778
                                                            if let Some(v1084) = v1083 {
2781
778
                                                                if v11.0 == v19.0 {
2782
778
                                                                    let v1050 = C::unpack_value_array_2(ctx, v1048);
2783
778
                                                                    let v1080 = C::unpack_value_array_2(ctx, v1078);
2784
778
                                                                    if v1050.0 == v1080.0 {
2785
79
                                                                        if v1050.1 == v1080.1 {
2786
0
                                                                            let v1085 = constructor_decompose_intcc(ctx, v1049);
2787
0
                                                                            let v1086 = constructor_decompose_intcc(ctx, v1079);
2788
0
                                                                            let v1087 = C::u64_and(ctx, v1085, v1086);
2789
0
                                                                            let v1088 = constructor_compose_icmp(ctx, v542, v1087, v1084, v1050.0, v1050.1);
2790
                                                                            // Rule at src/opts/icmp.isle line 175.
2791
0
                                                                            returns.extend(Some(v1088));
2792
0
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
2793
79
                                                                        }
2794
699
                                                                    }
2795
0
                                                                }
2796
0
                                                            }
2797
0
                                                        }
2798
528
                                                    }
2799
                                                }
2800
0
                                            }
2801
0
                                        }
2802
0
                                    }
2803
                                }
2804
                                &InstructionData::Unary {
2805
3.71k
                                    opcode: ref v26,
2806
3.71k
                                    arg: v27,
2807
                                } => {
2808
3.71k
                                    match v26 {
2809
                                        &Opcode::Splat => {
2810
0
                                            let v1380 = C::ty_vector_not_float(ctx, v2.0);
2811
0
                                            if let Some(v1381) = v1380 {
2812
0
                                                if v2.0 == v11.0 {
2813
0
                                                    let mut v18 = C::inst_data_value_etor_returns::default();
2814
0
                                                    C::inst_data_value_etor(ctx, v7.0, &mut v18);
2815
0
                                                    let mut v18 = v18.into_context_iter();
2816
0
                                                    while let Some(v19) = v18.next(ctx) {
2817
                                                        if let &InstructionData::Unary {
2818
0
                                                            opcode: ref v29,
2819
0
                                                            arg: v30,
2820
0
                                                        } = &v19.1 {
2821
0
                                                            if let &Opcode::Splat = v29 {
2822
0
                                                                if v2.0 == v19.0 {
2823
0
                                                                    let v1262 = C::lane_type(ctx, v2.0);
2824
0
                                                                    let v1382 = constructor_band(ctx, v1262, v30, v27);
2825
0
                                                                    let v1383 = constructor_splat(ctx, v2.0, v1382);
2826
                                                                    // Rule at src/opts/vector.isle line 14.
2827
0
                                                                    returns.extend(Some(v1383));
2828
0
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
2829
0
                                                                }
2830
0
                                                            }
2831
0
                                                        }
2832
                                                    }
2833
0
                                                }
2834
0
                                            }
2835
                                        }
2836
                                        &Opcode::Bnot => {
2837
140
                                            let v52 = C::ty_int(ctx, v2.0);
2838
140
                                            if let Some(v53) = v52 {
2839
140
                                                if v7.0 == v27 {
2840
0
                                                    if v11.0 == v53 {
2841
0
                                                        let v55 = constructor_iconst_u(ctx, v53, 0x0_u64);
2842
0
                                                        let v56 = C::subsume(ctx, v55);
2843
                                                        // Rule at src/opts/bitops.isle line 34.
2844
0
                                                        returns.extend(Some(v56));
2845
0
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
2846
0
                                                    }
2847
140
                                                }
2848
0
                                            }
2849
                                        }
2850
                                        &Opcode::Uextend => {
2851
3.19k
                                            let mut v18 = C::inst_data_value_etor_returns::default();
2852
3.19k
                                            C::inst_data_value_etor(ctx, v7.0, &mut v18);
2853
3.19k
                                            let mut v18 = v18.into_context_iter();
2854
8.22k
                                            while let Some(
v195.03k
) = v18.next(ctx) {
2855
                                                if let &InstructionData::Unary {
2856
2.63k
                                                    opcode: ref v29,
2857
2.63k
                                                    arg: v30,
2858
5.03k
                                                } = &v19.1 {
2859
2.63k
                                                    if let &Opcode::Uextend = v29 {
2860
2.63k
                                                        let v939 = C::value_type(ctx, v30);
2861
2.63k
                                                        let v974 = C::value_type(ctx, v27);
2862
2.63k
                                                        if v939 == v974 {
2863
2.63k
                                                            let v975 = constructor_band(ctx, v939, v30, v27);
2864
2.63k
                                                            let v976 = constructor_uextend(ctx, v2.0, v975);
2865
                                                            // Rule at src/opts/extends.isle line 70.
2866
2.63k
                                                            returns.extend(Some(v976));
2867
2.63k
                                                            if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
2868
0
                                                        }
2869
0
                                                    }
2870
2.40k
                                                }
2871
                                            }
2872
                                        }
2873
382
                                        _ => {}
2874
                                    }
2875
                                }
2876
                                &InstructionData::UnaryImm {
2877
53.9k
                                    opcode: ref v14,
2878
53.9k
                                    imm: v15,
2879
                                } => {
2880
53.9k
                                    if let &Opcode::Iconst = v14 {
2881
53.9k
                                        let mut v18 = C::inst_data_value_etor_returns::default();
2882
53.9k
                                        C::inst_data_value_etor(ctx, v7.0, &mut v18);
2883
53.9k
                                        let mut v18 = v18.into_context_iter();
2884
105k
                                        while let Some(
v1951.4k
) = v18.next(ctx) {
2885
51.4k
                                            match &v19.1 {
2886
                                                &InstructionData::Binary {
2887
6.49k
                                                    opcode: ref v122,
2888
6.49k
                                                    args: ref v123,
2889
                                                } => {
2890
6.49k
                                                    if let &Opcode::Band = v122 {
2891
197
                                                        if v2.0 == v11.0 {
2892
197
                                                            if v2.0 == v19.0 {
2893
197
                                                                let v124 = C::unpack_value_array_2(ctx, v123);
2894
197
                                                                let mut v199 = C::inst_data_value_etor_returns::default();
2895
197
                                                                C::inst_data_value_etor(ctx, v124.1, &mut v199);
2896
197
                                                                let mut v199 = v199.into_context_iter();
2897
419
                                                                while let Some(
v200222
) = v199.next(ctx) {
2898
                                                                    if let &InstructionData::UnaryImm {
2899
104
                                                                        opcode: ref v241,
2900
104
                                                                        imm: v242,
2901
222
                                                                    } = &v200.1 {
2902
104
                                                                        if let &Opcode::Iconst = v241 {
2903
104
                                                                            if v2.0 == v200.0 {
2904
104
                                                                                let v642 = constructor_band(ctx, v2.0, v124.1, v7.1);
2905
104
                                                                                let v643 = constructor_band(ctx, v2.0, v124.0, v642);
2906
                                                                                // Rule at src/opts/cprop.isle line 160.
2907
104
                                                                                returns.extend(Some(v643));
2908
104
                                                                                if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
2909
0
                                                                            }
2910
0
                                                                        }
2911
118
                                                                    }
2912
                                                                }
2913
0
                                                            }
2914
0
                                                        }
2915
6.29k
                                                    }
2916
                                                }
2917
                                                &InstructionData::IntCompare {
2918
0
                                                    opcode: ref v1047,
2919
0
                                                    args: ref v1048,
2920
0
                                                    cond: ref v1049,
2921
                                                } => {
2922
0
                                                    if let &Opcode::Icmp = v1047 {
2923
0
                                                        let v16 = C::u64_from_imm64(ctx, v15);
2924
0
                                                        if v16 == 0x1_u64 {
2925
0
                                                            let v52 = C::ty_int(ctx, v2.0);
2926
0
                                                            if let Some(v53) = v52 {
2927
                                                                // Rule at src/opts/icmp.isle line 86.
2928
0
                                                                returns.extend(Some(v7.0));
2929
0
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
2930
0
                                                            }
2931
0
                                                        }
2932
0
                                                    }
2933
                                                }
2934
                                                &InstructionData::Unary {
2935
1.38k
                                                    opcode: ref v29,
2936
1.38k
                                                    arg: v30,
2937
                                                } => {
2938
1.38k
                                                    match v29 {
2939
                                                        &Opcode::Uextend => {
2940
122
                                                            let v16 = C::u64_from_imm64(ctx, v15);
2941
122
                                                            if v16 == 0x1_u64 {
2942
2
                                                                let v52 = C::ty_int(ctx, v2.0);
2943
2
                                                                if let Some(v53) = v52 {
2944
2
                                                                    let mut v1053 = C::inst_data_value_etor_returns::default();
2945
2
                                                                    C::inst_data_value_etor(ctx, v30, &mut v1053);
2946
2
                                                                    let mut v1053 = v1053.into_context_iter();
2947
2
                                                                    while let Some(
v10540
) = v1053.next(ctx) {
2948
                                                                        if let &InstructionData::IntCompare {
2949
0
                                                                            opcode: ref v1057,
2950
0
                                                                            args: ref v1058,
2951
0
                                                                            cond: ref v1059,
2952
0
                                                                        } = &v1054.1 {
2953
0
                                                                            if let &Opcode::Icmp = v1057 {
2954
                                                                                // Rule at src/opts/icmp.isle line 91.
2955
0
                                                                                returns.extend(Some(v7.0));
2956
0
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
2957
0
                                                                            }
2958
0
                                                                        }
2959
                                                                    }
2960
0
                                                                }
2961
120
                                                            }
2962
122
                                                            let v939 = C::value_type(ctx, v30);
2963
122
                                                            let v940 = C::ty_mask(ctx, v939);
2964
122
                                                            let v941 = C::u64_and(ctx, v16, v940);
2965
122
                                                            let v942 = C::u64_eq(ctx, v940, v941);
2966
122
                                                            if v942 == true {
2967
                                                                // Rule at src/opts/extends.isle line 16.
2968
1
                                                                returns.extend(Some(v7.0));
2969
1
                                                                if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
2970
121
                                                            }
2971
                                                        }
2972
                                                        &Opcode::Sextend => {
2973
93
                                                            let v16 = C::u64_from_imm64(ctx, v15);
2974
93
                                                            let v939 = C::value_type(ctx, v30);
2975
93
                                                            let v940 = C::ty_mask(ctx, v939);
2976
93
                                                            let v943 = C::u64_eq(ctx, v16, v940);
2977
93
                                                            if v943 == true {
2978
66
                                                                let v944 = constructor_uextend(ctx, v2.0, v30);
2979
                                                                // Rule at src/opts/extends.isle line 22.
2980
66
                                                                returns.extend(Some(v944));
2981
66
                                                                if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
2982
27
                                                            }
2983
                                                        }
2984
1.17k
                                                        _ => {}
2985
                                                    }
2986
                                                }
2987
                                                &InstructionData::UnaryImm {
2988
613
                                                    opcode: ref v22,
2989
613
                                                    imm: v23,
2990
                                                } => {
2991
613
                                                    if let &Opcode::Iconst = v22 {
2992
613
                                                        let v541 = C::fits_in_64(ctx, v2.0);
2993
613
                                                        if let Some(v542) = v541 {
2994
613
                                                            if v11.0 == v19.0 {
2995
613
                                                                if v11.0 == v542 {
2996
613
                                                                    let v24 = C::u64_from_imm64(ctx, v23);
2997
613
                                                                    let v16 = C::u64_from_imm64(ctx, v15);
2998
613
                                                                    let v559 = C::u64_and(ctx, v24, v16);
2999
613
                                                                    let v560 = C::imm64_masked(ctx, v542, v559);
3000
613
                                                                    let v561 = constructor_iconst(ctx, v542, v560);
3001
613
                                                                    let v562 = C::subsume(ctx, v561);
3002
                                                                    // Rule at src/opts/cprop.isle line 38.
3003
613
                                                                    returns.extend(Some(v562));
3004
613
                                                                    if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
3005
0
                                                                }
3006
0
                                                            }
3007
0
                                                        }
3008
0
                                                    }
3009
                                                }
3010
42.9k
                                                _ => {}
3011
                                            }
3012
                                        }
3013
53.9k
                                        let v16 = C::u64_from_imm64(ctx, v15);
3014
53.9k
                                        if v16 == 0x0_u64 {
3015
0
                                            if v2.0 == v11.0 {
3016
0
                                                let v57 = C::subsume(ctx, v7.1);
3017
                                                // Rule at src/opts/bitops.isle line 33.
3018
0
                                                returns.extend(Some(v57));
3019
0
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
3020
0
                                            }
3021
53.9k
                                        }
3022
53.9k
                                        let v1142 = C::remat(ctx, arg0);
3023
                                        // Rule at src/opts/remat.isle line 13.
3024
53.9k
                                        returns.extend(Some(v1142));
3025
53.9k
                                        if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
3026
0
                                    }
3027
                                }
3028
614
                                _ => {}
3029
                            }
3030
                        }
3031
61.6k
                        let mut v18 = C::inst_data_value_etor_returns::default();
3032
61.6k
                        C::inst_data_value_etor(ctx, v7.0, &mut v18);
3033
61.6k
                        let mut v18 = v18.into_context_iter();
3034
122k
                        while let Some(
v1961.1k
) = v18.next(ctx) {
3035
61.1k
                            match &v19.1 {
3036
                                &InstructionData::Binary {
3037
12.0k
                                    opcode: ref v122,
3038
12.0k
                                    args: ref v123,
3039
                                } => {
3040
12.0k
                                    if let &Opcode::Band = v122 {
3041
4.98k
                                        if v2.0 == v19.0 {
3042
4.98k
                                            let v124 = C::unpack_value_array_2(ctx, v123);
3043
4.98k
                                            let mut v127 = C::inst_data_value_etor_returns::default();
3044
4.98k
                                            C::inst_data_value_etor(ctx, v124.0, &mut v127);
3045
4.98k
                                            let mut v127 = v127.into_context_iter();
3046
11.4k
                                            while let Some(
v1286.50k
) = v127.next(ctx) {
3047
                                                if let &InstructionData::Binary {
3048
2.85k
                                                    opcode: ref v131,
3049
2.85k
                                                    args: ref v132,
3050
6.50k
                                                } = &v128.1 {
3051
2.85k
                                                    if let &Opcode::Band = v131 {
3052
2.66k
                                                        if v2.0 == v128.0 {
3053
2.66k
                                                            let v133 = C::unpack_value_array_2(ctx, v132);
3054
2.66k
                                                            let v152 = constructor_band(ctx, v2.0, v133.0, v133.1);
3055
2.66k
                                                            let v153 = constructor_band(ctx, v2.0, v124.1, v7.1);
3056
2.66k
                                                            let v154 = constructor_band(ctx, v2.0, v152, v153);
3057
2.66k
                                                            let v155 = C::subsume(ctx, v154);
3058
                                                            // Rule at src/opts/arithmetic.isle line 224.
3059
2.66k
                                                            returns.extend(Some(v155));
3060
2.66k
                                                            if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
3061
0
                                                        }
3062
184
                                                    }
3063
3.65k
                                                }
3064
                                            }
3065
0
                                        }
3066
7.03k
                                    }
3067
                                }
3068
                                &InstructionData::Unary {
3069
4.37k
                                    opcode: ref v29,
3070
4.37k
                                    arg: v30,
3071
                                } => {
3072
4.37k
                                    if let &Opcode::Bnot = v29 {
3073
132
                                        if v7.1 == v30 {
3074
0
                                            let v52 = C::ty_int(ctx, v2.0);
3075
0
                                            if let Some(v53) = v52 {
3076
0
                                                if v19.0 == v53 {
3077
0
                                                    let v55 = constructor_iconst_u(ctx, v53, 0x0_u64);
3078
0
                                                    let v56 = C::subsume(ctx, v55);
3079
                                                    // Rule at src/opts/bitops.isle line 35.
3080
0
                                                    returns.extend(Some(v56));
3081
0
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
3082
0
                                                }
3083
0
                                            }
3084
132
                                        }
3085
4.23k
                                    }
3086
                                }
3087
                                &InstructionData::UnaryImm {
3088
613
                                    opcode: ref v22,
3089
613
                                    imm: v23,
3090
                                } => {
3091
613
                                    if let &Opcode::Iconst = v22 {
3092
613
                                        if v2.0 == v19.0 {
3093
613
                                            let v612 = constructor_band(ctx, v2.0, v7.1, v7.0);
3094
                                            // Rule at src/opts/cprop.isle line 107.
3095
613
                                            returns.extend(Some(v612));
3096
613
                                            if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
3097
0
                                        }
3098
613
                                        let v1142 = C::remat(ctx, arg0);
3099
                                        // Rule at src/opts/remat.isle line 11.
3100
613
                                        returns.extend(Some(v1142));
3101
613
                                        if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
3102
0
                                    }
3103
                                }
3104
44.1k
                                _ => {}
3105
                            }
3106
                        }
3107
61.6k
                        if v7.0 == v7.1 {
3108
10
                            let v17 = C::subsume(ctx, v7.0);
3109
                            // Rule at src/opts/bitops.isle line 28.
3110
10
                            returns.extend(Some(v17));
3111
10
                            if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
3112
61.6k
                        }
3113
61.6k
                        let mut v58 = C::inst_data_value_tupled_etor_returns::default();
3114
61.6k
                        C::inst_data_value_tupled_etor(ctx, v7.1, &mut v58);
3115
61.6k
                        let mut v58 = v58.into_context_iter();
3116
125k
                        while let Some(
v5963.8k
) = v58.next(ctx) {
3117
63.8k
                            let v60 = C::iconst_sextend_etor(ctx, v59);
3118
63.8k
                            if let Some(
v6153.9k
) = v60 {
3119
53.9k
                                if v61.1 == -1_i64 {
3120
6
                                    if v2.0 == v61.0 {
3121
6
                                        let v17 = C::subsume(ctx, v7.0);
3122
                                        // Rule at src/opts/bitops.isle line 29.
3123
6
                                        returns.extend(Some(v17));
3124
6
                                        if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
3125
0
                                    }
3126
53.9k
                                }
3127
9.91k
                            }
3128
                        }
3129
                    }
3130
                    &Opcode::Bor => {
3131
40.5k
                        let v7 = C::unpack_value_array_2(ctx, v6);
3132
40.5k
                        let mut v10 = C::inst_data_value_etor_returns::default();
3133
40.5k
                        C::inst_data_value_etor(ctx, v7.1, &mut v10);
3134
40.5k
                        let mut v10 = v10.into_context_iter();
3135
79.8k
                        while let Some(
v1139.2k
) = v10.next(ctx) {
3136
39.2k
                            match &v11.1 {
3137
                                &InstructionData::Binary {
3138
5.47k
                                    opcode: ref v104,
3139
5.47k
                                    args: ref v105,
3140
                                } => {
3141
5.47k
                                    match v104 {
3142
                                        &Opcode::Band => {
3143
984
                                            let mut v18 = C::inst_data_value_etor_returns::default();
3144
984
                                            C::inst_data_value_etor(ctx, v7.0, &mut v18);
3145
984
                                            let mut v18 = v18.into_context_iter();
3146
1.90k
                                            while let Some(
v19924
) = v18.next(ctx) {
3147
924
                                                match &v19.1 {
3148
                                                    &InstructionData::Binary {
3149
721
                                                        opcode: ref v122,
3150
721
                                                        args: ref v123,
3151
                                                    } => {
3152
721
                                                        if let &Opcode::Band = v122 {
3153
179
                                                            let v1182 = C::ty_vec128(ctx, v2.0);
3154
179
                                                            if let Some(
v11830
) = v1182 {
3155
0
                                                                if v11.0 == v19.0 {
3156
0
                                                                    if v11.0 == v1183 {
3157
0
                                                                        let v106 = C::unpack_value_array_2(ctx, v105);
3158
0
                                                                        let mut v109 = C::inst_data_value_etor_returns::default();
3159
0
                                                                        C::inst_data_value_etor(ctx, v106.1, &mut v109);
3160
0
                                                                        let mut v109 = v109.into_context_iter();
3161
0
                                                                        while let Some(v110) = v109.next(ctx) {
3162
                                                                            if let &InstructionData::Unary {
3163
0
                                                                                opcode: ref v1187,
3164
0
                                                                                arg: v1188,
3165
0
                                                                            } = &v110.1 {
3166
0
                                                                                if let &Opcode::Bnot = v1187 {
3167
0
                                                                                    if v11.0 == v110.0 {
3168
0
                                                                                        let v124 = C::unpack_value_array_2(ctx, v123);
3169
0
                                                                                        if v124.0 == v1188 {
3170
0
                                                                                            let v1189 = constructor_bitselect(ctx, v1183, v124.0, v124.1, v106.0);
3171
                                                                                            // Rule at src/opts/selects.isle line 70.
3172
0
                                                                                            returns.extend(Some(v1189));
3173
0
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
3174
0
                                                                                        }
3175
0
                                                                                        if v124.1 == v1188 {
3176
0
                                                                                            let v1191 = constructor_bitselect(ctx, v1183, v124.1, v124.0, v106.0);
3177
                                                                                            // Rule at src/opts/selects.isle line 72.
3178
0
                                                                                            returns.extend(Some(v1191));
3179
0
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
3180
0
                                                                                        }
3181
0
                                                                                    }
3182
0
                                                                                }
3183
0
                                                                            }
3184
                                                                        }
3185
0
                                                                        let v124 = C::unpack_value_array_2(ctx, v123);
3186
0
                                                                        let mut v127 = C::inst_data_value_etor_returns::default();
3187
0
                                                                        C::inst_data_value_etor(ctx, v124.0, &mut v127);
3188
0
                                                                        let mut v127 = v127.into_context_iter();
3189
0
                                                                        while let Some(v128) = v127.next(ctx) {
3190
                                                                            if let &InstructionData::Unary {
3191
0
                                                                                opcode: ref v196,
3192
0
                                                                                arg: v197,
3193
0
                                                                            } = &v128.1 {
3194
0
                                                                                if let &Opcode::Bnot = v196 {
3195
0
                                                                                    if v11.0 == v128.0 {
3196
0
                                                                                        if v106.1 == v197 {
3197
0
                                                                                            let v1193 = constructor_bitselect(ctx, v1183, v197, v106.0, v124.1);
3198
                                                                                            // Rule at src/opts/selects.isle line 74.
3199
0
                                                                                            returns.extend(Some(v1193));
3200
0
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
3201
0
                                                                                        }
3202
0
                                                                                        if v106.0 == v197 {
3203
0
                                                                                            let v1192 = constructor_bitselect(ctx, v1183, v197, v106.1, v124.1);
3204
                                                                                            // Rule at src/opts/selects.isle line 73.
3205
0
                                                                                            returns.extend(Some(v1192));
3206
0
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
3207
0
                                                                                        }
3208
0
                                                                                    }
3209
0
                                                                                }
3210
0
                                                                            }
3211
                                                                        }
3212
0
                                                                        let mut v199 = C::inst_data_value_etor_returns::default();
3213
0
                                                                        C::inst_data_value_etor(ctx, v124.1, &mut v199);
3214
0
                                                                        let mut v199 = v199.into_context_iter();
3215
0
                                                                        while let Some(v200) = v199.next(ctx) {
3216
                                                                            if let &InstructionData::Unary {
3217
0
                                                                                opcode: ref v203,
3218
0
                                                                                arg: v204,
3219
0
                                                                            } = &v200.1 {
3220
0
                                                                                if let &Opcode::Bnot = v203 {
3221
0
                                                                                    if v11.0 == v200.0 {
3222
0
                                                                                        if v106.1 == v204 {
3223
0
                                                                                            let v1195 = constructor_bitselect(ctx, v1183, v204, v106.0, v124.0);
3224
                                                                                            // Rule at src/opts/selects.isle line 76.
3225
0
                                                                                            returns.extend(Some(v1195));
3226
0
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
3227
0
                                                                                        }
3228
0
                                                                                        if v106.0 == v204 {
3229
0
                                                                                            let v1194 = constructor_bitselect(ctx, v1183, v204, v106.1, v124.0);
3230
                                                                                            // Rule at src/opts/selects.isle line 75.
3231
0
                                                                                            returns.extend(Some(v1194));
3232
0
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
3233
0
                                                                                        }
3234
0
                                                                                    }
3235
0
                                                                                }
3236
0
                                                                            }
3237
                                                                        }
3238
0
                                                                        let mut v324 = C::inst_data_value_etor_returns::default();
3239
0
                                                                        C::inst_data_value_etor(ctx, v106.0, &mut v324);
3240
0
                                                                        let mut v324 = v324.into_context_iter();
3241
0
                                                                        while let Some(v325) = v324.next(ctx) {
3242
                                                                            if let &InstructionData::Unary {
3243
0
                                                                                opcode: ref v1184,
3244
0
                                                                                arg: v1185,
3245
0
                                                                            } = &v325.1 {
3246
0
                                                                                if let &Opcode::Bnot = v1184 {
3247
0
                                                                                    if v11.0 == v325.0 {
3248
0
                                                                                        if v124.0 == v1185 {
3249
0
                                                                                            let v1186 = constructor_bitselect(ctx, v1183, v124.0, v124.1, v106.1);
3250
                                                                                            // Rule at src/opts/selects.isle line 69.
3251
0
                                                                                            returns.extend(Some(v1186));
3252
0
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
3253
0
                                                                                        }
3254
0
                                                                                        if v124.1 == v1185 {
3255
0
                                                                                            let v1190 = constructor_bitselect(ctx, v1183, v124.1, v124.0, v106.1);
3256
                                                                                            // Rule at src/opts/selects.isle line 71.
3257
0
                                                                                            returns.extend(Some(v1190));
3258
0
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
3259
0
                                                                                        }
3260
0
                                                                                    }
3261
0
                                                                                }
3262
0
                                                                            }
3263
                                                                        }
3264
0
                                                                    }
3265
0
                                                                }
3266
179
                                                            }
3267
542
                                                        }
3268
                                                    }
3269
                                                    &InstructionData::Unary {
3270
108
                                                        opcode: ref v29,
3271
108
                                                        arg: v30,
3272
                                                    } => {
3273
108
                                                        if let &Opcode::Bnot = v29 {
3274
0
                                                            if v2.0 == v11.0 {
3275
0
                                                                if v2.0 == v19.0 {
3276
0
                                                                    let v106 = C::unpack_value_array_2(ctx, v105);
3277
0
                                                                    if v30 == v106.1 {
3278
0
                                                                        let v240 = constructor_bor(ctx, v2.0, v106.0, v7.0);
3279
                                                                        // Rule at src/opts/bitops.isle line 61.
3280
0
                                                                        returns.extend(Some(v240));
3281
0
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
3282
0
                                                                    }
3283
0
                                                                }
3284
0
                                                            }
3285
108
                                                        }
3286
                                                    }
3287
95
                                                    _ => {}
3288
                                                }
3289
                                            }
3290
                                        }
3291
                                        &Opcode::Bor => {
3292
556
                                            let mut v18 = C::inst_data_value_etor_returns::default();
3293
556
                                            C::inst_data_value_etor(ctx, v7.0, &mut v18);
3294
556
                                            let mut v18 = v18.into_context_iter();
3295
1.11k
                                            while let Some(
v19556
) = v18.next(ctx) {
3296
                                                if let &InstructionData::Binary {
3297
554
                                                    opcode: ref v122,
3298
554
                                                    args: ref v123,
3299
556
                                                } = &v19.1 {
3300
554
                                                    if let &Opcode::Bor = v122 {
3301
413
                                                        let v106 = C::unpack_value_array_2(ctx, v105);
3302
413
                                                        let mut v109 = C::inst_data_value_etor_returns::default();
3303
413
                                                        C::inst_data_value_etor(ctx, v106.1, &mut v109);
3304
413
                                                        let mut v109 = v109.into_context_iter();
3305
599
                                                        while let Some(
v110186
) = v109.next(ctx) {
3306
186
                                                            match &v110.1 {
3307
                                                                &InstructionData::Binary {
3308
56
                                                                    opcode: ref v113,
3309
56
                                                                    args: ref v114,
3310
                                                                } => {
3311
56
                                                                    match v113 {
3312
                                                                        &Opcode::Bor => {
3313
0
                                                                            if v2.0 == I64 {
3314
0
                                                                                if v11.0 == I64 {
3315
0
                                                                                    if v19.0 == I64 {
3316
0
                                                                                        if v110.0 == I64 {
3317
0
                                                                                            let v124 = C::unpack_value_array_2(ctx, v123);
3318
0
                                                                                            let mut v127 = C::inst_data_value_etor_returns::default();
3319
0
                                                                                            C::inst_data_value_etor(ctx, v124.0, &mut v127);
3320
0
                                                                                            let mut v127 = v127.into_context_iter();
3321
0
                                                                                            while let Some(v128) = v127.next(ctx) {
3322
0
                                                                                                if v128.0 == I64 {
3323
                                                                                                    if let &InstructionData::Binary {
3324
0
                                                                                                        opcode: ref v131,
3325
0
                                                                                                        args: ref v132,
3326
0
                                                                                                    } = &v128.1 {
3327
0
                                                                                                        if let &Opcode::Bor = v131 {
3328
0
                                                                                                            let mut v199 = C::inst_data_value_etor_returns::default();
3329
0
                                                                                                            C::inst_data_value_etor(ctx, v124.1, &mut v199);
3330
0
                                                                                                            let mut v199 = v199.into_context_iter();
3331
0
                                                                                                            while let Some(v200) = v199.next(ctx) {
3332
0
                                                                                                                if v200.0 == I64 {
3333
                                                                                                                    if let &InstructionData::Binary {
3334
0
                                                                                                                        opcode: ref v296,
3335
0
                                                                                                                        args: ref v297,
3336
0
                                                                                                                    } = &v200.1 {
3337
0
                                                                                                                        if let &Opcode::Bor = v296 {
3338
0
                                                                                                                            let v133 = C::unpack_value_array_2(ctx, v132);
3339
0
                                                                                                                            let mut v289 = C::inst_data_value_etor_returns::default();
3340
0
                                                                                                                            C::inst_data_value_etor(ctx, v133.1, &mut v289);
3341
0
                                                                                                                            let mut v289 = v289.into_context_iter();
3342
0
                                                                                                                            while let Some(v290) = v289.next(ctx) {
3343
0
                                                                                                                                if v290.0 == I64 {
3344
                                                                                                                                    if let &InstructionData::Binary {
3345
0
                                                                                                                                        opcode: ref v380,
3346
0
                                                                                                                                        args: ref v381,
3347
0
                                                                                                                                    } = &v290.1 {
3348
0
                                                                                                                                        if let &Opcode::Ishl = v380 {
3349
0
                                                                                                                                            let v298 = C::unpack_value_array_2(ctx, v297);
3350
0
                                                                                                                                            let mut v301 = C::inst_data_value_etor_returns::default();
3351
0
                                                                                                                                            C::inst_data_value_etor(ctx, v298.0, &mut v301);
3352
0
                                                                                                                                            let mut v301 = v301.into_context_iter();
3353
0
                                                                                                                                            while let Some(v302) = v301.next(ctx) {
3354
0
                                                                                                                                                if v302.0 == I64 {
3355
                                                                                                                                                    if let &InstructionData::Binary {
3356
0
                                                                                                                                                        opcode: ref v305,
3357
0
                                                                                                                                                        args: ref v306,
3358
0
                                                                                                                                                    } = &v302.1 {
3359
0
                                                                                                                                                        if let &Opcode::Ishl = v305 {
3360
0
                                                                                                                                                            let v307 = C::unpack_value_array_2(ctx, v306);
3361
0
                                                                                                                                                            let mut v310 = C::inst_data_value_etor_returns::default();
3362
0
                                                                                                                                                            C::inst_data_value_etor(ctx, v307.1, &mut v310);
3363
0
                                                                                                                                                            let mut v310 = v310.into_context_iter();
3364
0
                                                                                                                                                            while let Some(v311) = v310.next(ctx) {
3365
0
                                                                                                                                                                if v311.0 == I64 {
3366
                                                                                                                                                                    if let &InstructionData::UnaryImm {
3367
0
                                                                                                                                                                        opcode: ref v314,
3368
0
                                                                                                                                                                        imm: v315,
3369
0
                                                                                                                                                                    } = &v311.1 {
3370
0
                                                                                                                                                                        if let &Opcode::Iconst = v314 {
3371
0
                                                                                                                                                                            let v316 = C::u64_from_imm64(ctx, v315);
3372
0
                                                                                                                                                                            if v316 == 0x18_u64 {
3373
0
                                                                                                                                                                                let mut v317 = C::inst_data_value_etor_returns::default();
3374
0
                                                                                                                                                                                C::inst_data_value_etor(ctx, v298.1, &mut v317);
3375
0
                                                                                                                                                                                let mut v317 = v317.into_context_iter();
3376
0
                                                                                                                                                                                while let Some(v318) = v317.next(ctx) {
3377
0
                                                                                                                                                                                    if v318.0 == I64 {
3378
                                                                                                                                                                                        if let &InstructionData::Binary {
3379
0
                                                                                                                                                                                            opcode: ref v424,
3380
0
                                                                                                                                                                                            args: ref v425,
3381
0
                                                                                                                                                                                        } = &v318.1 {
3382
0
                                                                                                                                                                                            if let &Opcode::Ishl = v424 {
3383
0
                                                                                                                                                                                                let mut v324 = C::inst_data_value_etor_returns::default();
3384
0
                                                                                                                                                                                                C::inst_data_value_etor(ctx, v106.0, &mut v324);
3385
0
                                                                                                                                                                                                let mut v324 = v324.into_context_iter();
3386
0
                                                                                                                                                                                                while let Some(v325) = v324.next(ctx) {
3387
0
                                                                                                                                                                                                    if v325.0 == I64 {
3388
                                                                                                                                                                                                        if let &InstructionData::Binary {
3389
0
                                                                                                                                                                                                            opcode: ref v328,
3390
0
                                                                                                                                                                                                            args: ref v329,
3391
0
                                                                                                                                                                                                        } = &v325.1 {
3392
0
                                                                                                                                                                                                            if let &Opcode::Bor = v328 {
3393
0
                                                                                                                                                                                                                let v330 = C::unpack_value_array_2(ctx, v329);
3394
0
                                                                                                                                                                                                                let mut v333 = C::inst_data_value_etor_returns::default();
3395
0
                                                                                                                                                                                                                C::inst_data_value_etor(ctx, v330.0, &mut v333);
3396
0
                                                                                                                                                                                                                let mut v333 = v333.into_context_iter();
3397
0
                                                                                                                                                                                                                while let Some(v334) = v333.next(ctx) {
3398
0
                                                                                                                                                                                                                    if v334.0 == I64 {
3399
                                                                                                                                                                                                                        if let &InstructionData::Binary {
3400
0
                                                                                                                                                                                                                            opcode: ref v337,
3401
0
                                                                                                                                                                                                                            args: ref v338,
3402
0
                                                                                                                                                                                                                        } = &v334.1 {
3403
0
                                                                                                                                                                                                                            if let &Opcode::Band = v337 {
3404
0
                                                                                                                                                                                                                                let v339 = C::unpack_value_array_2(ctx, v338);
3405
0
                                                                                                                                                                                                                                let mut v342 = C::inst_data_value_etor_returns::default();
3406
0
                                                                                                                                                                                                                                C::inst_data_value_etor(ctx, v339.1, &mut v342);
3407
0
                                                                                                                                                                                                                                let mut v342 = v342.into_context_iter();
3408
0
                                                                                                                                                                                                                                while let Some(v343) = v342.next(ctx) {
3409
0
                                                                                                                                                                                                                                    if v343.0 == I64 {
3410
                                                                                                                                                                                                                                        if let &InstructionData::UnaryImm {
3411
0
                                                                                                                                                                                                                                            opcode: ref v346,
3412
0
                                                                                                                                                                                                                                            imm: v347,
3413
0
                                                                                                                                                                                                                                        } = &v343.1 {
3414
0
                                                                                                                                                                                                                                            if let &Opcode::Iconst = v346 {
3415
0
                                                                                                                                                                                                                                                let v348 = C::u64_from_imm64(ctx, v347);
3416
0
                                                                                                                                                                                                                                                if v348 == 0xff000000_u64 {
3417
0
                                                                                                                                                                                                                                                    let mut v349 = C::inst_data_value_etor_returns::default();
3418
0
                                                                                                                                                                                                                                                    C::inst_data_value_etor(ctx, v330.1, &mut v349);
3419
0
                                                                                                                                                                                                                                                    let mut v349 = v349.into_context_iter();
3420
0
                                                                                                                                                                                                                                                    while let Some(v350) = v349.next(ctx) {
3421
0
                                                                                                                                                                                                                                                        if v350.0 == I64 {
3422
                                                                                                                                                                                                                                                            if let &InstructionData::Binary {
3423
0
                                                                                                                                                                                                                                                                opcode: ref v468,
3424
0
                                                                                                                                                                                                                                                                args: ref v469,
3425
0
                                                                                                                                                                                                                                                            } = &v350.1 {
3426
0
                                                                                                                                                                                                                                                                if let &Opcode::Band = v468 {
3427
0
                                                                                                                                                                                                                                                                    let v115 = C::unpack_value_array_2(ctx, v114);
3428
0
                                                                                                                                                                                                                                                                    let mut v356 = C::inst_data_value_etor_returns::default();
3429
0
                                                                                                                                                                                                                                                                    C::inst_data_value_etor(ctx, v115.1, &mut v356);
3430
0
                                                                                                                                                                                                                                                                    let mut v356 = v356.into_context_iter();
3431
0
                                                                                                                                                                                                                                                                    while let Some(v357) = v356.next(ctx) {
3432
0
                                                                                                                                                                                                                                                                        if v357.0 == I64 {
3433
                                                                                                                                                                                                                                                                            if let &InstructionData::Binary {
3434
0
                                                                                                                                                                                                                                                                                opcode: ref v528,
3435
0
                                                                                                                                                                                                                                                                                args: ref v529,
3436
0
                                                                                                                                                                                                                                                                            } = &v357.1 {
3437
0
                                                                                                                                                                                                                                                                                if let &Opcode::Ushr = v528 {
3438
0
                                                                                                                                                                                                                                                                                    let mut v364 = C::inst_data_value_etor_returns::default();
3439
0
                                                                                                                                                                                                                                                                                    C::inst_data_value_etor(ctx, v133.0, &mut v364);
3440
0
                                                                                                                                                                                                                                                                                    let mut v364 = v364.into_context_iter();
3441
0
                                                                                                                                                                                                                                                                                    while let Some(v365) = v364.next(ctx) {
3442
0
                                                                                                                                                                                                                                                                                        if v365.0 == I64 {
3443
                                                                                                                                                                                                                                                                                            if let &InstructionData::Binary {
3444
0
                                                                                                                                                                                                                                                                                                opcode: ref v368,
3445
0
                                                                                                                                                                                                                                                                                                args: ref v369,
3446
0
                                                                                                                                                                                                                                                                                            } = &v365.1 {
3447
0
                                                                                                                                                                                                                                                                                                if let &Opcode::Ishl = v368 {
3448
0
                                                                                                                                                                                                                                                                                                    let v370 = C::unpack_value_array_2(ctx, v369);
3449
0
                                                                                                                                                                                                                                                                                                    let v530 = C::unpack_value_array_2(ctx, v529);
3450
0
                                                                                                                                                                                                                                                                                                    if v370.0 == v530.0 {
3451
0
                                                                                                                                                                                                                                                                                                        let mut v373 = C::inst_data_value_etor_returns::default();
3452
0
                                                                                                                                                                                                                                                                                                        C::inst_data_value_etor(ctx, v370.1, &mut v373);
3453
0
                                                                                                                                                                                                                                                                                                        let mut v373 = v373.into_context_iter();
3454
0
                                                                                                                                                                                                                                                                                                        while let Some(v374) = v373.next(ctx) {
3455
0
                                                                                                                                                                                                                                                                                                            if v374.0 == I64 {
3456
                                                                                                                                                                                                                                                                                                                if let &InstructionData::UnaryImm {
3457
0
                                                                                                                                                                                                                                                                                                                    opcode: ref v377,
3458
0
                                                                                                                                                                                                                                                                                                                    imm: v378,
3459
0
                                                                                                                                                                                                                                                                                                                } = &v374.1 {
3460
0
                                                                                                                                                                                                                                                                                                                    if let &Opcode::Iconst = v377 {
3461
0
                                                                                                                                                                                                                                                                                                                        let v379 = C::u64_from_imm64(ctx, v378);
3462
0
                                                                                                                                                                                                                                                                                                                        if v379 == 0x38_u64 {
3463
0
                                                                                                                                                                                                                                                                                                                            let v382 = C::unpack_value_array_2(ctx, v381);
3464
0
                                                                                                                                                                                                                                                                                                                            let mut v385 = C::inst_data_value_etor_returns::default();
3465
0
                                                                                                                                                                                                                                                                                                                            C::inst_data_value_etor(ctx, v382.0, &mut v385);
3466
0
                                                                                                                                                                                                                                                                                                                            let mut v385 = v385.into_context_iter();
3467
0
                                                                                                                                                                                                                                                                                                                            while let Some(v386) = v385.next(ctx) {
3468
0
                                                                                                                                                                                                                                                                                                                                if v386.0 == I64 {
3469
                                                                                                                                                                                                                                                                                                                                    if let &InstructionData::Binary {
3470
0
                                                                                                                                                                                                                                                                                                                                        opcode: ref v389,
3471
0
                                                                                                                                                                                                                                                                                                                                        args: ref v390,
3472
0
                                                                                                                                                                                                                                                                                                                                    } = &v386.1 {
3473
0
                                                                                                                                                                                                                                                                                                                                        if let &Opcode::Band = v389 {
3474
0
                                                                                                                                                                                                                                                                                                                                            let v391 = C::unpack_value_array_2(ctx, v390);
3475
0
                                                                                                                                                                                                                                                                                                                                            if v370.0 == v391.0 {
3476
0
                                                                                                                                                                                                                                                                                                                                                let mut v394 = C::inst_data_value_etor_returns::default();
3477
0
                                                                                                                                                                                                                                                                                                                                                C::inst_data_value_etor(ctx, v391.1, &mut v394);
3478
0
                                                                                                                                                                                                                                                                                                                                                let mut v394 = v394.into_context_iter();
3479
0
                                                                                                                                                                                                                                                                                                                                                while let Some(v395) = v394.next(ctx) {
3480
0
                                                                                                                                                                                                                                                                                                                                                    if v395.0 == I64 {
3481
                                                                                                                                                                                                                                                                                                                                                        if let &InstructionData::UnaryImm {
3482
0
                                                                                                                                                                                                                                                                                                                                                            opcode: ref v398,
3483
0
                                                                                                                                                                                                                                                                                                                                                            imm: v399,
3484
0
                                                                                                                                                                                                                                                                                                                                                        } = &v395.1 {
3485
0
                                                                                                                                                                                                                                                                                                                                                            if let &Opcode::Iconst = v398 {
3486
0
                                                                                                                                                                                                                                                                                                                                                                let v400 = C::u64_from_imm64(ctx, v399);
3487
0
                                                                                                                                                                                                                                                                                                                                                                if v400 == 0xff00_u64 {
3488
0
                                                                                                                                                                                                                                                                                                                                                                    let mut v401 = C::inst_data_value_etor_returns::default();
3489
0
                                                                                                                                                                                                                                                                                                                                                                    C::inst_data_value_etor(ctx, v382.1, &mut v401);
3490
0
                                                                                                                                                                                                                                                                                                                                                                    let mut v401 = v401.into_context_iter();
3491
0
                                                                                                                                                                                                                                                                                                                                                                    while let Some(v402) = v401.next(ctx) {
3492
0
                                                                                                                                                                                                                                                                                                                                                                        if v402.0 == I64 {
3493
                                                                                                                                                                                                                                                                                                                                                                            if let &InstructionData::UnaryImm {
3494
0
                                                                                                                                                                                                                                                                                                                                                                                opcode: ref v405,
3495
0
                                                                                                                                                                                                                                                                                                                                                                                imm: v406,
3496
0
                                                                                                                                                                                                                                                                                                                                                                            } = &v402.1 {
3497
0
                                                                                                                                                                                                                                                                                                                                                                                if let &Opcode::Iconst = v405 {
3498
0
                                                                                                                                                                                                                                                                                                                                                                                    let v407 = C::u64_from_imm64(ctx, v406);
3499
0
                                                                                                                                                                                                                                                                                                                                                                                    if v407 == 0x28_u64 {
3500
0
                                                                                                                                                                                                                                                                                                                                                                                        let mut v408 = C::inst_data_value_etor_returns::default();
3501
0
                                                                                                                                                                                                                                                                                                                                                                                        C::inst_data_value_etor(ctx, v307.0, &mut v408);
3502
0
                                                                                                                                                                                                                                                                                                                                                                                        let mut v408 = v408.into_context_iter();
3503
0
                                                                                                                                                                                                                                                                                                                                                                                        while let Some(v409) = v408.next(ctx) {
3504
0
                                                                                                                                                                                                                                                                                                                                                                                            if v409.0 == I64 {
3505
                                                                                                                                                                                                                                                                                                                                                                                                if let &InstructionData::Binary {
3506
0
                                                                                                                                                                                                                                                                                                                                                                                                    opcode: ref v412,
3507
0
                                                                                                                                                                                                                                                                                                                                                                                                    args: ref v413,
3508
0
                                                                                                                                                                                                                                                                                                                                                                                                } = &v409.1 {
3509
0
                                                                                                                                                                                                                                                                                                                                                                                                    if let &Opcode::Band = v412 {
3510
0
                                                                                                                                                                                                                                                                                                                                                                                                        let v414 = C::unpack_value_array_2(ctx, v413);
3511
0
                                                                                                                                                                                                                                                                                                                                                                                                        if v370.0 == v414.0 {
3512
0
                                                                                                                                                                                                                                                                                                                                                                                                            let mut v417 = C::inst_data_value_etor_returns::default();
3513
0
                                                                                                                                                                                                                                                                                                                                                                                                            C::inst_data_value_etor(ctx, v414.1, &mut v417);
3514
0
                                                                                                                                                                                                                                                                                                                                                                                                            let mut v417 = v417.into_context_iter();
3515
0
                                                                                                                                                                                                                                                                                                                                                                                                            while let Some(v418) = v417.next(ctx) {
3516
0
                                                                                                                                                                                                                                                                                                                                                                                                                if v418.0 == I64 {
3517
                                                                                                                                                                                                                                                                                                                                                                                                                    if let &InstructionData::UnaryImm {
3518
0
                                                                                                                                                                                                                                                                                                                                                                                                                        opcode: ref v421,
3519
0
                                                                                                                                                                                                                                                                                                                                                                                                                        imm: v422,
3520
0
                                                                                                                                                                                                                                                                                                                                                                                                                    } = &v418.1 {
3521
0
                                                                                                                                                                                                                                                                                                                                                                                                                        if let &Opcode::Iconst = v421 {
3522
0
                                                                                                                                                                                                                                                                                                                                                                                                                            let v423 = C::u64_from_imm64(ctx, v422);
3523
0
                                                                                                                                                                                                                                                                                                                                                                                                                            if v423 == 0xff0000_u64 {
3524
0
                                                                                                                                                                                                                                                                                                                                                                                                                                let v426 = C::unpack_value_array_2(ctx, v425);
3525
0
                                                                                                                                                                                                                                                                                                                                                                                                                                let mut v429 = C::inst_data_value_etor_returns::default();
3526
0
                                                                                                                                                                                                                                                                                                                                                                                                                                C::inst_data_value_etor(ctx, v426.0, &mut v429);
3527
0
                                                                                                                                                                                                                                                                                                                                                                                                                                let mut v429 = v429.into_context_iter();
3528
0
                                                                                                                                                                                                                                                                                                                                                                                                                                while let Some(v430) = v429.next(ctx) {
3529
0
                                                                                                                                                                                                                                                                                                                                                                                                                                    if v430.0 == I64 {
3530
                                                                                                                                                                                                                                                                                                                                                                                                                                        if let &InstructionData::Binary {
3531
0
                                                                                                                                                                                                                                                                                                                                                                                                                                            opcode: ref v433,
3532
0
                                                                                                                                                                                                                                                                                                                                                                                                                                            args: ref v434,
3533
0
                                                                                                                                                                                                                                                                                                                                                                                                                                        } = &v430.1 {
3534
0
                                                                                                                                                                                                                                                                                                                                                                                                                                            if let &Opcode::Band = v433 {
3535
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                let v435 = C::unpack_value_array_2(ctx, v434);
3536
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                if v370.0 == v435.0 {
3537
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mut v438 = C::inst_data_value_etor_returns::default();
3538
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                    C::inst_data_value_etor(ctx, v435.1, &mut v438);
3539
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mut v438 = v438.into_context_iter();
3540
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                    while let Some(v439) = v438.next(ctx) {
3541
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                        if v439.0 == I64 {
3542
                                                                                                                                                                                                                                                                                                                                                                                                                                                            if let &InstructionData::UnaryImm {
3543
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                opcode: ref v442,
3544
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                imm: v443,
3545
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                            } = &v439.1 {
3546
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                if let &Opcode::Iconst = v442 {
3547
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let v444 = C::u64_from_imm64(ctx, v443);
3548
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if v444 == 0xff000000_u64 {
3549
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mut v445 = C::inst_data_value_etor_returns::default();
3550
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        C::inst_data_value_etor(ctx, v426.1, &mut v445);
3551
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mut v445 = v445.into_context_iter();
3552
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        while let Some(v446) = v445.next(ctx) {
3553
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if v446.0 == I64 {
3554
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if let &InstructionData::UnaryImm {
3555
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    opcode: ref v449,
3556
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    imm: v450,
3557
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } = &v446.1 {
3558
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if let &Opcode::Iconst = v449 {
3559
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let v451 = C::u64_from_imm64(ctx, v450);
3560
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if v451 == 0x8_u64 {
3561
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mut v452 = C::inst_data_value_etor_returns::default();
3562
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            C::inst_data_value_etor(ctx, v339.0, &mut v452);
3563
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mut v452 = v452.into_context_iter();
3564
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            while let Some(v453) = v452.next(ctx) {
3565
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if v453.0 == I64 {
3566
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if let &InstructionData::Binary {
3567
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        opcode: ref v456,
3568
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        args: ref v457,
3569
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } = &v453.1 {
3570
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if let &Opcode::Ushr = v456 {
3571
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let v458 = C::unpack_value_array_2(ctx, v457);
3572
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if v370.0 == v458.0 {
3573
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mut v461 = C::inst_data_value_etor_returns::default();
3574
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                C::inst_data_value_etor(ctx, v458.1, &mut v461);
3575
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mut v461 = v461.into_context_iter();
3576
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                while let Some(v462) = v461.next(ctx) {
3577
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if v462.0 == I64 {
3578
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if let &InstructionData::UnaryImm {
3579
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            opcode: ref v465,
3580
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            imm: v466,
3581
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } = &v462.1 {
3582
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if let &Opcode::Iconst = v465 {
3583
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let v467 = C::u64_from_imm64(ctx, v466);
3584
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if v467 == 0x8_u64 {
3585
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let v470 = C::unpack_value_array_2(ctx, v469);
3586
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mut v473 = C::inst_data_value_etor_returns::default();
3587
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    C::inst_data_value_etor(ctx, v470.0, &mut v473);
3588
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mut v473 = v473.into_context_iter();
3589
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    while let Some(v474) = v473.next(ctx) {
3590
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if v474.0 == I64 {
3591
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if let &InstructionData::Binary {
3592
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                opcode: ref v477,
3593
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                args: ref v478,
3594
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } = &v474.1 {
3595
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if let &Opcode::Ushr = v477 {
3596
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let v479 = C::unpack_value_array_2(ctx, v478);
3597
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if v370.0 == v479.0 {
3598
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mut v482 = C::inst_data_value_etor_returns::default();
3599
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        C::inst_data_value_etor(ctx, v479.1, &mut v482);
3600
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mut v482 = v482.into_context_iter();
3601
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        while let Some(v483) = v482.next(ctx) {
3602
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if v483.0 == I64 {
3603
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if let &InstructionData::UnaryImm {
3604
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    opcode: ref v486,
3605
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    imm: v487,
3606
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } = &v483.1 {
3607
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if let &Opcode::Iconst = v486 {
3608
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let v488 = C::u64_from_imm64(ctx, v487);
3609
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if v488 == 0x18_u64 {
3610
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mut v489 = C::inst_data_value_etor_returns::default();
3611
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            C::inst_data_value_etor(ctx, v470.1, &mut v489);
3612
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mut v489 = v489.into_context_iter();
3613
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            while let Some(v490) = v489.next(ctx) {
3614
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if v490.0 == I64 {
3615
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if let &InstructionData::UnaryImm {
3616
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        opcode: ref v493,
3617
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        imm: v494,
3618
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } = &v490.1 {
3619
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if let &Opcode::Iconst = v493 {
3620
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let v495 = C::u64_from_imm64(ctx, v494);
3621
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if v495 == 0xff0000_u64 {
3622
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mut v496 = C::inst_data_value_etor_returns::default();
3623
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                C::inst_data_value_etor(ctx, v115.0, &mut v496);
3624
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mut v496 = v496.into_context_iter();
3625
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                while let Some(v497) = v496.next(ctx) {
3626
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if v497.0 == I64 {
3627
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if let &InstructionData::Binary {
3628
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            opcode: ref v500,
3629
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            args: ref v501,
3630
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } = &v497.1 {
3631
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if let &Opcode::Band = v500 {
3632
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let v502 = C::unpack_value_array_2(ctx, v501);
3633
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mut v505 = C::inst_data_value_etor_returns::default();
3634
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                C::inst_data_value_etor(ctx, v502.0, &mut v505);
3635
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let mut v505 = v505.into_context_iter();
3636
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                while let Some(v506) = v505.next(ctx) {
3637
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if v506.0 == I64 {
3638
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if let &InstructionData::Binary {
3639
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            opcode: ref v509,
3640
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            args: ref v510,
3641
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } = &v506.1 {
3642
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if let &Opcode::Ushr = v509 {
3643
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let v511 = C::unpack_value_array_2(ctx, v510);
3644
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if v370.0 == v511.0 {
3645
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mut v514 = C::inst_data_value_etor_returns::default();
3646
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    C::inst_data_value_etor(ctx, v511.1, &mut v514);
3647
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let mut v514 = v514.into_context_iter();
3648
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    while let Some(v515) = v514.next(ctx) {
3649
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if v515.0 == I64 {
3650
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if let &InstructionData::UnaryImm {
3651
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                opcode: ref v518,
3652
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                imm: v519,
3653
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            } = &v515.1 {
3654
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if let &Opcode::Iconst = v518 {
3655
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let v520 = C::u64_from_imm64(ctx, v519);
3656
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if v520 == 0x28_u64 {
3657
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mut v521 = C::inst_data_value_etor_returns::default();
3658
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        C::inst_data_value_etor(ctx, v502.1, &mut v521);
3659
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let mut v521 = v521.into_context_iter();
3660
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        while let Some(v522) = v521.next(ctx) {
3661
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if v522.0 == I64 {
3662
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if let &InstructionData::UnaryImm {
3663
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    opcode: ref v525,
3664
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    imm: v526,
3665
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                } = &v522.1 {
3666
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if let &Opcode::Iconst = v525 {
3667
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let v527 = C::u64_from_imm64(ctx, v526);
3668
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if v527 == 0xff00_u64 {
3669
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mut v533 = C::inst_data_value_etor_returns::default();
3670
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            C::inst_data_value_etor(ctx, v530.1, &mut v533);
3671
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let mut v533 = v533.into_context_iter();
3672
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            while let Some(v534) = v533.next(ctx) {
3673
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if v534.0 == I64 {
3674
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if let &InstructionData::UnaryImm {
3675
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        opcode: ref v537,
3676
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        imm: v538,
3677
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } = &v534.1 {
3678
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if let &Opcode::Iconst = v537 {
3679
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            let v539 = C::u64_from_imm64(ctx, v538);
3680
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if v539 == 0x38_u64 {
3681
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let v540 = constructor_bswap(ctx, v2.0, v370.0);
3682
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                // Rule at src/opts/bitops.isle line 163.
3683
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                returns.extend(Some(v540));
3684
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
3685
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
3686
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
3687
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
3688
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
3689
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
3690
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
3691
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
3692
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
3693
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
3694
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
3695
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
3696
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
3697
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
3698
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
3699
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
3700
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
3701
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
3702
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
3703
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
3704
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
3705
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
3706
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
3707
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
3708
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
3709
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
3710
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
3711
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
3712
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
3713
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
3714
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
3715
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
3716
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
3717
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
3718
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
3719
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
3720
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
3721
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
3722
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
3723
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
3724
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
3725
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
3726
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
3727
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
3728
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
3729
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
3730
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
3731
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
3732
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
3733
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
3734
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
3735
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
3736
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
3737
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
3738
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
3739
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
3740
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
3741
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
3742
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
3743
                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
3744
0
                                                                                                                                                                                                                                                                                                                                                                                                                                                }
3745
0
                                                                                                                                                                                                                                                                                                                                                                                                                                            }
3746
0
                                                                                                                                                                                                                                                                                                                                                                                                                                        }
3747
0
                                                                                                                                                                                                                                                                                                                                                                                                                                    }
3748
                                                                                                                                                                                                                                                                                                                                                                                                                                }
3749
0
                                                                                                                                                                                                                                                                                                                                                                                                                            }
3750
0
                                                                                                                                                                                                                                                                                                                                                                                                                        }
3751
0
                                                                                                                                                                                                                                                                                                                                                                                                                    }
3752
0
                                                                                                                                                                                                                                                                                                                                                                                                                }
3753
                                                                                                                                                                                                                                                                                                                                                                                                            }
3754
0
                                                                                                                                                                                                                                                                                                                                                                                                        }
3755
0
                                                                                                                                                                                                                                                                                                                                                                                                    }
3756
0
                                                                                                                                                                                                                                                                                                                                                                                                }
3757
0
                                                                                                                                                                                                                                                                                                                                                                                            }
3758
                                                                                                                                                                                                                                                                                                                                                                                        }
3759
0
                                                                                                                                                                                                                                                                                                                                                                                    }
3760
0
                                                                                                                                                                                                                                                                                                                                                                                }
3761
0
                                                                                                                                                                                                                                                                                                                                                                            }
3762
0
                                                                                                                                                                                                                                                                                                                                                                        }
3763
                                                                                                                                                                                                                                                                                                                                                                    }
3764
0
                                                                                                                                                                                                                                                                                                                                                                }
3765
0
                                                                                                                                                                                                                                                                                                                                                            }
3766
0
                                                                                                                                                                                                                                                                                                                                                        }
3767
0
                                                                                                                                                                                                                                                                                                                                                    }
3768
                                                                                                                                                                                                                                                                                                                                                }
3769
0
                                                                                                                                                                                                                                                                                                                                            }
3770
0
                                                                                                                                                                                                                                                                                                                                        }
3771
0
                                                                                                                                                                                                                                                                                                                                    }
3772
0
                                                                                                                                                                                                                                                                                                                                }
3773
                                                                                                                                                                                                                                                                                                                            }
3774
0
                                                                                                                                                                                                                                                                                                                        }
3775
0
                                                                                                                                                                                                                                                                                                                    }
3776
0
                                                                                                                                                                                                                                                                                                                }
3777
0
                                                                                                                                                                                                                                                                                                            }
3778
                                                                                                                                                                                                                                                                                                        }
3779
0
                                                                                                                                                                                                                                                                                                    }
3780
0
                                                                                                                                                                                                                                                                                                }
3781
0
                                                                                                                                                                                                                                                                                            }
3782
0
                                                                                                                                                                                                                                                                                        }
3783
                                                                                                                                                                                                                                                                                    }
3784
0
                                                                                                                                                                                                                                                                                }
3785
0
                                                                                                                                                                                                                                                                            }
3786
0
                                                                                                                                                                                                                                                                        }
3787
                                                                                                                                                                                                                                                                    }
3788
0
                                                                                                                                                                                                                                                                }
3789
0
                                                                                                                                                                                                                                                            }
3790
0
                                                                                                                                                                                                                                                        }
3791
                                                                                                                                                                                                                                                    }
3792
0
                                                                                                                                                                                                                                                }
3793
0
                                                                                                                                                                                                                                            }
3794
0
                                                                                                                                                                                                                                        }
3795
0
                                                                                                                                                                                                                                    }
3796
                                                                                                                                                                                                                                }
3797
0
                                                                                                                                                                                                                            }
3798
0
                                                                                                                                                                                                                        }
3799
0
                                                                                                                                                                                                                    }
3800
                                                                                                                                                                                                                }
3801
0
                                                                                                                                                                                                            }
3802
0
                                                                                                                                                                                                        }
3803
0
                                                                                                                                                                                                    }
3804
                                                                                                                                                                                                }
3805
0
                                                                                                                                                                                            }
3806
0
                                                                                                                                                                                        }
3807
0
                                                                                                                                                                                    }
3808
                                                                                                                                                                                }
3809
0
                                                                                                                                                                            }
3810
0
                                                                                                                                                                        }
3811
0
                                                                                                                                                                    }
3812
0
                                                                                                                                                                }
3813
                                                                                                                                                            }
3814
0
                                                                                                                                                        }
3815
0
                                                                                                                                                    }
3816
0
                                                                                                                                                }
3817
                                                                                                                                            }
3818
0
                                                                                                                                        }
3819
0
                                                                                                                                    }
3820
0
                                                                                                                                }
3821
                                                                                                                            }
3822
0
                                                                                                                        }
3823
0
                                                                                                                    }
3824
0
                                                                                                                }
3825
                                                                                                            }
3826
0
                                                                                                        }
3827
0
                                                                                                    }
3828
0
                                                                                                }
3829
                                                                                            }
3830
0
                                                                                        }
3831
0
                                                                                    }
3832
0
                                                                                }
3833
0
                                                                            }
3834
                                                                        }
3835
                                                                        &Opcode::Ushr => {
3836
1
                                                                            if v2.0 == I32 {
3837
1
                                                                                if v11.0 == I32 {
3838
1
                                                                                    if v19.0 == I32 {
3839
1
                                                                                        if v110.0 == I32 {
3840
1
                                                                                            let v124 = C::unpack_value_array_2(ctx, v123);
3841
1
                                                                                            let mut v127 = C::inst_data_value_etor_returns::default();
3842
1
                                                                                            C::inst_data_value_etor(ctx, v124.0, &mut v127);
3843
1
                                                                                            let mut v127 = v127.into_context_iter();
3844
2
                                                                                            while let Some(
v1281
) = v127.next(ctx) {
3845
1
                                                                                                if v128.0 == I32 {
3846
                                                                                                    if let &InstructionData::Binary {
3847
1
                                                                                                        opcode: ref v131,
3848
1
                                                                                                        args: ref v132,
3849
1
                                                                                                    } = &v128.1 {
3850
1
                                                                                                        if let &Opcode::Ishl = v131 {
3851
1
                                                                                                            let v115 = C::unpack_value_array_2(ctx, v114);
3852
1
                                                                                                            let v133 = C::unpack_value_array_2(ctx, v132);
3853
1
                                                                                                            if v115.0 == v133.0 {
3854
1
                                                                                                                let mut v199 = C::inst_data_value_etor_returns::default();
3855
1
                                                                                                                C::inst_data_value_etor(ctx, v124.1, &mut v199);
3856
1
                                                                                                                let mut v199 = v199.into_context_iter();
3857
2
                                                                                                                while let Some(
v2001
) = v199.next(ctx) {
3858
1
                                                                                                                    if v200.0 == I32 {
3859
                                                                                                                        if let &InstructionData::Binary {
3860
1
                                                                                                                            opcode: ref v296,
3861
1
                                                                                                                            args: ref v297,
3862
1
                                                                                                                        } = &v200.1 {
3863
1
                                                                                                                            if let &Opcode::Ishl = v296 {
3864
0
                                                                                                                                let mut v289 = C::inst_data_value_etor_returns::default();
3865
0
                                                                                                                                C::inst_data_value_etor(ctx, v133.1, &mut v289);
3866
0
                                                                                                                                let mut v289 = v289.into_context_iter();
3867
0
                                                                                                                                while let Some(v290) = v289.next(ctx) {
3868
0
                                                                                                                                    if v290.0 == I32 {
3869
                                                                                                                                        if let &InstructionData::UnaryImm {
3870
0
                                                                                                                                            opcode: ref v293,
3871
0
                                                                                                                                            imm: v294,
3872
0
                                                                                                                                        } = &v290.1 {
3873
0
                                                                                                                                            if let &Opcode::Iconst = v293 {
3874
0
                                                                                                                                                let v295 = C::u64_from_imm64(ctx, v294);
3875
0
                                                                                                                                                if v295 == 0x18_u64 {
3876
0
                                                                                                                                                    let v298 = C::unpack_value_array_2(ctx, v297);
3877
0
                                                                                                                                                    let mut v301 = C::inst_data_value_etor_returns::default();
3878
0
                                                                                                                                                    C::inst_data_value_etor(ctx, v298.0, &mut v301);
3879
0
                                                                                                                                                    let mut v301 = v301.into_context_iter();
3880
0
                                                                                                                                                    while let Some(v302) = v301.next(ctx) {
3881
0
                                                                                                                                                        if v302.0 == I32 {
3882
                                                                                                                                                            if let &InstructionData::Binary {
3883
0
                                                                                                                                                                opcode: ref v305,
3884
0
                                                                                                                                                                args: ref v306,
3885
0
                                                                                                                                                            } = &v302.1 {
3886
0
                                                                                                                                                                if let &Opcode::Band = v305 {
3887
0
                                                                                                                                                                    let v307 = C::unpack_value_array_2(ctx, v306);
3888
0
                                                                                                                                                                    if v115.0 == v307.0 {
3889
0
                                                                                                                                                                        let mut v310 = C::inst_data_value_etor_returns::default();
3890
0
                                                                                                                                                                        C::inst_data_value_etor(ctx, v307.1, &mut v310);
3891
0
                                                                                                                                                                        let mut v310 = v310.into_context_iter();
3892
0
                                                                                                                                                                        while let Some(v311) = v310.next(ctx) {
3893
0
                                                                                                                                                                            if v311.0 == I32 {
3894
                                                                                                                                                                                if let &InstructionData::UnaryImm {
3895
0
                                                                                                                                                                                    opcode: ref v314,
3896
0
                                                                                                                                                                                    imm: v315,
3897
0
                                                                                                                                                                                } = &v311.1 {
3898
0
                                                                                                                                                                                    if let &Opcode::Iconst = v314 {
3899
0
                                                                                                                                                                                        let v316 = C::u64_from_imm64(ctx, v315);
3900
0
                                                                                                                                                                                        if v316 == 0xff00_u64 {
3901
0
                                                                                                                                                                                            let mut v317 = C::inst_data_value_etor_returns::default();
3902
0
                                                                                                                                                                                            C::inst_data_value_etor(ctx, v298.1, &mut v317);
3903
0
                                                                                                                                                                                            let mut v317 = v317.into_context_iter();
3904
0
                                                                                                                                                                                            while let Some(v318) = v317.next(ctx) {
3905
0
                                                                                                                                                                                                if v318.0 == I32 {
3906
                                                                                                                                                                                                    if let &InstructionData::UnaryImm {
3907
0
                                                                                                                                                                                                        opcode: ref v321,
3908
0
                                                                                                                                                                                                        imm: v322,
3909
0
                                                                                                                                                                                                    } = &v318.1 {
3910
0
                                                                                                                                                                                                        if let &Opcode::Iconst = v321 {
3911
0
                                                                                                                                                                                                            let v323 = C::u64_from_imm64(ctx, v322);
3912
0
                                                                                                                                                                                                            if v323 == 0x8_u64 {
3913
0
                                                                                                                                                                                                                let mut v324 = C::inst_data_value_etor_returns::default();
3914
0
                                                                                                                                                                                                                C::inst_data_value_etor(ctx, v106.0, &mut v324);
3915
0
                                                                                                                                                                                                                let mut v324 = v324.into_context_iter();
3916
0
                                                                                                                                                                                                                while let Some(v325) = v324.next(ctx) {
3917
0
                                                                                                                                                                                                                    if v325.0 == I32 {
3918
                                                                                                                                                                                                                        if let &InstructionData::Binary {
3919
0
                                                                                                                                                                                                                            opcode: ref v328,
3920
0
                                                                                                                                                                                                                            args: ref v329,
3921
0
                                                                                                                                                                                                                        } = &v325.1 {
3922
0
                                                                                                                                                                                                                            if let &Opcode::Band = v328 {
3923
0
                                                                                                                                                                                                                                let v330 = C::unpack_value_array_2(ctx, v329);
3924
0
                                                                                                                                                                                                                                let mut v333 = C::inst_data_value_etor_returns::default();
3925
0
                                                                                                                                                                                                                                C::inst_data_value_etor(ctx, v330.0, &mut v333);
3926
0
                                                                                                                                                                                                                                let mut v333 = v333.into_context_iter();
3927
0
                                                                                                                                                                                                                                while let Some(v334) = v333.next(ctx) {
3928
0
                                                                                                                                                                                                                                    if v334.0 == I32 {
3929
                                                                                                                                                                                                                                        if let &InstructionData::Binary {
3930
0
                                                                                                                                                                                                                                            opcode: ref v337,
3931
0
                                                                                                                                                                                                                                            args: ref v338,
3932
0
                                                                                                                                                                                                                                        } = &v334.1 {
3933
0
                                                                                                                                                                                                                                            if let &Opcode::Ushr = v337 {
3934
0
                                                                                                                                                                                                                                                let v339 = C::unpack_value_array_2(ctx, v338);
3935
0
                                                                                                                                                                                                                                                if v115.0 == v339.0 {
3936
0
                                                                                                                                                                                                                                                    let mut v342 = C::inst_data_value_etor_returns::default();
3937
0
                                                                                                                                                                                                                                                    C::inst_data_value_etor(ctx, v339.1, &mut v342);
3938
0
                                                                                                                                                                                                                                                    let mut v342 = v342.into_context_iter();
3939
0
                                                                                                                                                                                                                                                    while let Some(v343) = v342.next(ctx) {
3940
0
                                                                                                                                                                                                                                                        if v343.0 == I32 {
3941
                                                                                                                                                                                                                                                            if let &InstructionData::UnaryImm {
3942
0
                                                                                                                                                                                                                                                                opcode: ref v346,
3943
0
                                                                                                                                                                                                                                                                imm: v347,
3944
0
                                                                                                                                                                                                                                                            } = &v343.1 {
3945
0
                                                                                                                                                                                                                                                                if let &Opcode::Iconst = v346 {
3946
0
                                                                                                                                                                                                                                                                    let v348 = C::u64_from_imm64(ctx, v347);
3947
0
                                                                                                                                                                                                                                                                    if v348 == 0x8_u64 {
3948
0
                                                                                                                                                                                                                                                                        let mut v349 = C::inst_data_value_etor_returns::default();
3949
0
                                                                                                                                                                                                                                                                        C::inst_data_value_etor(ctx, v330.1, &mut v349);
3950
0
                                                                                                                                                                                                                                                                        let mut v349 = v349.into_context_iter();
3951
0
                                                                                                                                                                                                                                                                        while let Some(v350) = v349.next(ctx) {
3952
0
                                                                                                                                                                                                                                                                            if v350.0 == I32 {
3953
                                                                                                                                                                                                                                                                                if let &InstructionData::UnaryImm {
3954
0
                                                                                                                                                                                                                                                                                    opcode: ref v353,
3955
0
                                                                                                                                                                                                                                                                                    imm: v354,
3956
0
                                                                                                                                                                                                                                                                                } = &v350.1 {
3957
0
                                                                                                                                                                                                                                                                                    if let &Opcode::Iconst = v353 {
3958
0
                                                                                                                                                                                                                                                                                        let v355 = C::u64_from_imm64(ctx, v354);
3959
0
                                                                                                                                                                                                                                                                                        if v355 == 0xff00_u64 {
3960
0
                                                                                                                                                                                                                                                                                            let mut v356 = C::inst_data_value_etor_returns::default();
3961
0
                                                                                                                                                                                                                                                                                            C::inst_data_value_etor(ctx, v115.1, &mut v356);
3962
0
                                                                                                                                                                                                                                                                                            let mut v356 = v356.into_context_iter();
3963
0
                                                                                                                                                                                                                                                                                            while let Some(v357) = v356.next(ctx) {
3964
0
                                                                                                                                                                                                                                                                                                if v357.0 == I32 {
3965
                                                                                                                                                                                                                                                                                                    if let &InstructionData::UnaryImm {
3966
0
                                                                                                                                                                                                                                                                                                        opcode: ref v360,
3967
0
                                                                                                                                                                                                                                                                                                        imm: v361,
3968
0
                                                                                                                                                                                                                                                                                                    } = &v357.1 {
3969
0
                                                                                                                                                                                                                                                                                                        if let &Opcode::Iconst = v360 {
3970
0
                                                                                                                                                                                                                                                                                                            let v362 = C::u64_from_imm64(ctx, v361);
3971
0
                                                                                                                                                                                                                                                                                                            if v362 == 0x18_u64 {
3972
0
                                                                                                                                                                                                                                                                                                                let v363 = constructor_bswap(ctx, v2.0, v133.0);
3973
                                                                                                                                                                                                                                                                                                                // Rule at src/opts/bitops.isle line 150.
3974
0
                                                                                                                                                                                                                                                                                                                returns.extend(Some(v363));
3975
0
                                                                                                                                                                                                                                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
3976
0
                                                                                                                                                                                                                                                                                                            }
3977
0
                                                                                                                                                                                                                                                                                                        }
3978
0
                                                                                                                                                                                                                                                                                                    }
3979
0
                                                                                                                                                                                                                                                                                                }
3980
                                                                                                                                                                                                                                                                                            }
3981
0
                                                                                                                                                                                                                                                                                        }
3982
0
                                                                                                                                                                                                                                                                                    }
3983
0
                                                                                                                                                                                                                                                                                }
3984
0
                                                                                                                                                                                                                                                                            }
3985
                                                                                                                                                                                                                                                                        }
3986
0
                                                                                                                                                                                                                                                                    }
3987
0
                                                                                                                                                                                                                                                                }
3988
0
                                                                                                                                                                                                                                                            }
3989
0
                                                                                                                                                                                                                                                        }
3990
                                                                                                                                                                                                                                                    }
3991
0
                                                                                                                                                                                                                                                }
3992
0
                                                                                                                                                                                                                                            }
3993
0
                                                                                                                                                                                                                                        }
3994
0
                                                                                                                                                                                                                                    }
3995
                                                                                                                                                                                                                                }
3996
0
                                                                                                                                                                                                                            }
3997
0
                                                                                                                                                                                                                        }
3998
0
                                                                                                                                                                                                                    }
3999
                                                                                                                                                                                                                }
4000
0
                                                                                                                                                                                                            }
4001
0
                                                                                                                                                                                                        }
4002
0
                                                                                                                                                                                                    }
4003
0
                                                                                                                                                                                                }
4004
                                                                                                                                                                                            }
4005
0
                                                                                                                                                                                        }
4006
0
                                                                                                                                                                                    }
4007
0
                                                                                                                                                                                }
4008
0
                                                                                                                                                                            }
4009
                                                                                                                                                                        }
4010
0
                                                                                                                                                                    }
4011
0
                                                                                                                                                                }
4012
0
                                                                                                                                                            }
4013
0
                                                                                                                                                        }
4014
                                                                                                                                                    }
4015
0
                                                                                                                                                }
4016
0
                                                                                                                                            }
4017
0
                                                                                                                                        }
4018
0
                                                                                                                                    }
4019
                                                                                                                                }
4020
1
                                                                                                                            }
4021
0
                                                                                                                        }
4022
0
                                                                                                                    }
4023
                                                                                                                }
4024
0
                                                                                                            }
4025
0
                                                                                                        }
4026
0
                                                                                                    }
4027
0
                                                                                                }
4028
                                                                                            }
4029
0
                                                                                        }
4030
0
                                                                                    }
4031
0
                                                                                }
4032
0
                                                                            }
4033
                                                                        }
4034
55
                                                                        _ => {}
4035
                                                                    }
4036
                                                                }
4037
                                                                &InstructionData::UnaryImm {
4038
0
                                                                    opcode: ref v724,
4039
0
                                                                    imm: v725,
4040
                                                                } => {
4041
0
                                                                    if let &Opcode::Iconst = v724 {
4042
0
                                                                        if v2.0 == v11.0 {
4043
0
                                                                            if v2.0 == v19.0 {
4044
0
                                                                                let v124 = C::unpack_value_array_2(ctx, v123);
4045
0
                                                                                let mut v199 = C::inst_data_value_etor_returns::default();
4046
0
                                                                                C::inst_data_value_etor(ctx, v124.1, &mut v199);
4047
0
                                                                                let mut v199 = v199.into_context_iter();
4048
0
                                                                                while let Some(v200) = v199.next(ctx) {
4049
                                                                                    if let &InstructionData::UnaryImm {
4050
0
                                                                                        opcode: ref v241,
4051
0
                                                                                        imm: v242,
4052
0
                                                                                    } = &v200.1 {
4053
0
                                                                                        if let &Opcode::Iconst = v241 {
4054
0
                                                                                            let v735 = constructor_bor(ctx, v2.0, v124.0, v106.0);
4055
0
                                                                                            let v736 = constructor_bor(ctx, v2.0, v124.1, v106.1);
4056
0
                                                                                            let v737 = constructor_bor(ctx, v2.0, v735, v736);
4057
                                                                                            // Rule at src/opts/cprop.isle line 253.
4058
0
                                                                                            returns.extend(Some(v737));
4059
0
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
4060
0
                                                                                        }
4061
0
                                                                                    }
4062
                                                                                }
4063
0
                                                                            }
4064
0
                                                                        }
4065
0
                                                                    }
4066
                                                                }
4067
130
                                                                _ => {}
4068
                                                            }
4069
                                                        }
4070
141
                                                    }
4071
2
                                                }
4072
                                            }
4073
                                        }
4074
                                        &Opcode::Ishl => {
4075
2.81k
                                            let v52 = C::ty_int(ctx, v2.0);
4076
2.81k
                                            if let Some(v53) = v52 {
4077
2.81k
                                                if v11.0 == v53 {
4078
2.81k
                                                    let mut v18 = C::inst_data_value_etor_returns::default();
4079
2.81k
                                                    C::inst_data_value_etor(ctx, v7.0, &mut v18);
4080
2.81k
                                                    let mut v18 = v18.into_context_iter();
4081
5.48k
                                                    while let Some(
v192.66k
) = v18.next(ctx) {
4082
                                                        if let &InstructionData::Binary {
4083
1.06k
                                                            opcode: ref v122,
4084
1.06k
                                                            args: ref v123,
4085
2.66k
                                                        } = &v19.1 {
4086
1.06k
                                                            if let &Opcode::Ushr = v122 {
4087
599
                                                                if v11.0 == v19.0 {
4088
599
                                                                    let v106 = C::unpack_value_array_2(ctx, v105);
4089
599
                                                                    let v124 = C::unpack_value_array_2(ctx, v123);
4090
599
                                                                    if v106.0 == v124.0 {
4091
0
                                                                        let mut v109 = C::inst_data_value_etor_returns::default();
4092
0
                                                                        C::inst_data_value_etor(ctx, v106.1, &mut v109);
4093
0
                                                                        let mut v109 = v109.into_context_iter();
4094
0
                                                                        while let Some(v110) = v109.next(ctx) {
4095
                                                                            if let &InstructionData::UnaryImm {
4096
0
                                                                                opcode: ref v724,
4097
0
                                                                                imm: v725,
4098
0
                                                                            } = &v110.1 {
4099
0
                                                                                if let &Opcode::Iconst = v724 {
4100
0
                                                                                    let mut v199 = C::inst_data_value_etor_returns::default();
4101
0
                                                                                    C::inst_data_value_etor(ctx, v124.1, &mut v199);
4102
0
                                                                                    let mut v199 = v199.into_context_iter();
4103
0
                                                                                    while let Some(v200) = v199.next(ctx) {
4104
                                                                                        if let &InstructionData::UnaryImm {
4105
0
                                                                                            opcode: ref v241,
4106
0
                                                                                            imm: v242,
4107
0
                                                                                        } = &v200.1 {
4108
0
                                                                                            if let &Opcode::Iconst = v241 {
4109
0
                                                                                                let v243 = C::u64_from_imm64(ctx, v242);
4110
0
                                                                                                let v1279 = C::lane_type(ctx, v53);
4111
0
                                                                                                let v1280 = C::ty_bits_u64(ctx, v1279);
4112
0
                                                                                                let v994 = C::u64_from_imm64(ctx, v725);
4113
0
                                                                                                let v1284 = C::u64_wrapping_sub(ctx, v1280, v994);
4114
0
                                                                                                let v1285 = C::u64_eq(ctx, v243, v1284);
4115
0
                                                                                                if v1285 == true {
4116
0
                                                                                                    let v1286 = constructor_rotl(ctx, v53, v124.0, v106.1);
4117
                                                                                                    // Rule at src/opts/shifts.isle line 280.
4118
0
                                                                                                    returns.extend(Some(v1286));
4119
0
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
4120
0
                                                                                                }
4121
0
                                                                                            }
4122
0
                                                                                        }
4123
                                                                                    }
4124
0
                                                                                }
4125
0
                                                                            }
4126
                                                                        }
4127
599
                                                                    }
4128
0
                                                                }
4129
462
                                                            }
4130
1.60k
                                                        }
4131
                                                    }
4132
0
                                                }
4133
0
                                            }
4134
                                        }
4135
                                        &Opcode::Ushr => {
4136
376
                                            let v52 = C::ty_int(ctx, v2.0);
4137
376
                                            if let Some(v53) = v52 {
4138
376
                                                if v11.0 == v53 {
4139
376
                                                    let mut v18 = C::inst_data_value_etor_returns::default();
4140
376
                                                    C::inst_data_value_etor(ctx, v7.0, &mut v18);
4141
376
                                                    let mut v18 = v18.into_context_iter();
4142
857
                                                    while let Some(
v19481
) = v18.next(ctx) {
4143
                                                        if let &InstructionData::Binary {
4144
475
                                                            opcode: ref v122,
4145
475
                                                            args: ref v123,
4146
481
                                                        } = &v19.1 {
4147
475
                                                            if let &Opcode::Ishl = v122 {
4148
447
                                                                if v11.0 == v19.0 {
4149
447
                                                                    let v106 = C::unpack_value_array_2(ctx, v105);
4150
447
                                                                    let v124 = C::unpack_value_array_2(ctx, v123);
4151
447
                                                                    if v106.0 == v124.0 {
4152
0
                                                                        let mut v109 = C::inst_data_value_etor_returns::default();
4153
0
                                                                        C::inst_data_value_etor(ctx, v106.1, &mut v109);
4154
0
                                                                        let mut v109 = v109.into_context_iter();
4155
0
                                                                        while let Some(v110) = v109.next(ctx) {
4156
                                                                            if let &InstructionData::UnaryImm {
4157
0
                                                                                opcode: ref v724,
4158
0
                                                                                imm: v725,
4159
0
                                                                            } = &v110.1 {
4160
0
                                                                                if let &Opcode::Iconst = v724 {
4161
0
                                                                                    let mut v199 = C::inst_data_value_etor_returns::default();
4162
0
                                                                                    C::inst_data_value_etor(ctx, v124.1, &mut v199);
4163
0
                                                                                    let mut v199 = v199.into_context_iter();
4164
0
                                                                                    while let Some(v200) = v199.next(ctx) {
4165
                                                                                        if let &InstructionData::UnaryImm {
4166
0
                                                                                            opcode: ref v241,
4167
0
                                                                                            imm: v242,
4168
0
                                                                                        } = &v200.1 {
4169
0
                                                                                            if let &Opcode::Iconst = v241 {
4170
0
                                                                                                let v994 = C::u64_from_imm64(ctx, v725);
4171
0
                                                                                                let v1279 = C::lane_type(ctx, v53);
4172
0
                                                                                                let v1280 = C::ty_bits_u64(ctx, v1279);
4173
0
                                                                                                let v243 = C::u64_from_imm64(ctx, v242);
4174
0
                                                                                                let v1281 = C::u64_wrapping_sub(ctx, v1280, v243);
4175
0
                                                                                                let v1282 = C::u64_eq(ctx, v994, v1281);
4176
0
                                                                                                if v1282 == true {
4177
0
                                                                                                    let v1283 = constructor_rotl(ctx, v53, v124.0, v124.1);
4178
                                                                                                    // Rule at src/opts/shifts.isle line 275.
4179
0
                                                                                                    returns.extend(Some(v1283));
4180
0
                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
4181
0
                                                                                                }
4182
0
                                                                                            }
4183
0
                                                                                        }
4184
                                                                                    }
4185
0
                                                                                }
4186
0
                                                                            }
4187
                                                                        }
4188
447
                                                                    }
4189
0
                                                                }
4190
28
                                                            }
4191
6
                                                        }
4192
                                                    }
4193
0
                                                }
4194
0
                                            }
4195
                                        }
4196
737
                                        _ => {}
4197
                                    }
4198
                                }
4199
                                &InstructionData::IntCompare {
4200
751
                                    opcode: ref v1077,
4201
751
                                    args: ref v1078,
4202
751
                                    cond: ref v1079,
4203
                                } => {
4204
751
                                    if let &Opcode::Icmp = v1077 {
4205
751
                                        let v541 = C::fits_in_64(ctx, v2.0);
4206
751
                                        if let Some(v542) = v541 {
4207
751
                                            if v11.0 == v542 {
4208
751
                                                let mut v18 = C::inst_data_value_etor_returns::default();
4209
751
                                                C::inst_data_value_etor(ctx, v7.0, &mut v18);
4210
751
                                                let mut v18 = v18.into_context_iter();
4211
1.50k
                                                while let Some(
v19753
) = v18.next(ctx) {
4212
                                                    if let &InstructionData::IntCompare {
4213
307
                                                        opcode: ref v1047,
4214
307
                                                        args: ref v1048,
4215
307
                                                        cond: ref v1049,
4216
753
                                                    } = &v19.1 {
4217
307
                                                        if let &Opcode::Icmp = v1047 {
4218
307
                                                            let v1083 = constructor_intcc_comparable(ctx, v1049, v1079);
4219
307
                                                            if let Some(v1084) = v1083 {
4220
307
                                                                if v11.0 == v19.0 {
4221
307
                                                                    let v1050 = C::unpack_value_array_2(ctx, v1048);
4222
307
                                                                    let v1080 = C::unpack_value_array_2(ctx, v1078);
4223
307
                                                                    if v1050.0 == v1080.0 {
4224
3
                                                                        if v1050.1 == v1080.1 {
4225
0
                                                                            let v1085 = constructor_decompose_intcc(ctx, v1049);
4226
0
                                                                            let v1086 = constructor_decompose_intcc(ctx, v1079);
4227
0
                                                                            let v1089 = C::u64_or(ctx, v1085, v1086);
4228
0
                                                                            let v1090 = constructor_compose_icmp(ctx, v542, v1089, v1084, v1050.0, v1050.1);
4229
                                                                            // Rule at src/opts/icmp.isle line 179.
4230
0
                                                                            returns.extend(Some(v1090));
4231
0
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
4232
3
                                                                        }
4233
304
                                                                    }
4234
0
                                                                }
4235
0
                                                            }
4236
0
                                                        }
4237
446
                                                    }
4238
                                                }
4239
0
                                            }
4240
0
                                        }
4241
0
                                    }
4242
                                }
4243
                                &InstructionData::Unary {
4244
4.24k
                                    opcode: ref v26,
4245
4.24k
                                    arg: v27,
4246
                                } => {
4247
4.24k
                                    match v26 {
4248
                                        &Opcode::Splat => {
4249
0
                                            let v1380 = C::ty_vector_not_float(ctx, v2.0);
4250
0
                                            if let Some(v1381) = v1380 {
4251
0
                                                if v2.0 == v11.0 {
4252
0
                                                    let mut v18 = C::inst_data_value_etor_returns::default();
4253
0
                                                    C::inst_data_value_etor(ctx, v7.0, &mut v18);
4254
0
                                                    let mut v18 = v18.into_context_iter();
4255
0
                                                    while let Some(v19) = v18.next(ctx) {
4256
                                                        if let &InstructionData::Unary {
4257
0
                                                            opcode: ref v29,
4258
0
                                                            arg: v30,
4259
0
                                                        } = &v19.1 {
4260
0
                                                            if let &Opcode::Splat = v29 {
4261
0
                                                                if v2.0 == v19.0 {
4262
0
                                                                    let v1262 = C::lane_type(ctx, v2.0);
4263
0
                                                                    let v1384 = constructor_bor(ctx, v1262, v30, v27);
4264
0
                                                                    let v1385 = constructor_splat(ctx, v2.0, v1384);
4265
                                                                    // Rule at src/opts/vector.isle line 18.
4266
0
                                                                    returns.extend(Some(v1385));
4267
0
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
4268
0
                                                                }
4269
0
                                                            }
4270
0
                                                        }
4271
                                                    }
4272
0
                                                }
4273
0
                                            }
4274
                                        }
4275
                                        &Opcode::Bnot => {
4276
4
                                            let v52 = C::ty_int(ctx, v2.0);
4277
4
                                            if let Some(v53) = v52 {
4278
4
                                                if v7.0 == v27 {
4279
0
                                                    if v11.0 == v53 {
4280
0
                                                        let v232 = constructor_iconst_s(ctx, v53, -1_i64);
4281
0
                                                        let v233 = C::subsume(ctx, v232);
4282
                                                        // Rule at src/opts/bitops.isle line 24.
4283
0
                                                        returns.extend(Some(v233));
4284
0
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
4285
0
                                                    }
4286
4
                                                }
4287
0
                                            }
4288
4
                                            if v2.0 == v11.0 {
4289
4
                                                let mut v18 = C::inst_data_value_etor_returns::default();
4290
4
                                                C::inst_data_value_etor(ctx, v7.0, &mut v18);
4291
4
                                                let mut v18 = v18.into_context_iter();
4292
8
                                                while let Some(
v194
) = v18.next(ctx) {
4293
                                                    if let &InstructionData::Binary {
4294
0
                                                        opcode: ref v122,
4295
0
                                                        args: ref v123,
4296
4
                                                    } = &v19.1 {
4297
0
                                                        if let &Opcode::Band = v122 {
4298
0
                                                            if v2.0 == v19.0 {
4299
0
                                                                let v124 = C::unpack_value_array_2(ctx, v123);
4300
0
                                                                if v27 == v124.1 {
4301
0
                                                                    let v239 = constructor_bor(ctx, v2.0, v124.0, v7.1);
4302
                                                                    // Rule at src/opts/bitops.isle line 52.
4303
0
                                                                    returns.extend(Some(v239));
4304
0
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
4305
0
                                                                }
4306
0
                                                            }
4307
0
                                                        }
4308
4
                                                    }
4309
                                                }
4310
0
                                            }
4311
                                        }
4312
                                        &Opcode::Uextend => {
4313
4.22k
                                            let mut v18 = C::inst_data_value_etor_returns::default();
4314
4.22k
                                            C::inst_data_value_etor(ctx, v7.0, &mut v18);
4315
4.22k
                                            let mut v18 = v18.into_context_iter();
4316
8.59k
                                            while let Some(
v194.37k
) = v18.next(ctx) {
4317
                                                if let &InstructionData::Unary {
4318
878
                                                    opcode: ref v29,
4319
878
                                                    arg: v30,
4320
4.37k
                                                } = &v19.1 {
4321
878
                                                    if let &Opcode::Uextend = v29 {
4322
878
                                                        let v939 = C::value_type(ctx, v30);
4323
878
                                                        let v974 = C::value_type(ctx, v27);
4324
878
                                                        if v939 == v974 {
4325
878
                                                            let v977 = constructor_bor(ctx, v939, v30, v27);
4326
878
                                                            let v978 = constructor_uextend(ctx, v2.0, v977);
4327
                                                            // Rule at src/opts/extends.isle line 72.
4328
878
                                                            returns.extend(Some(v978));
4329
878
                                                            if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
4330
0
                                                        }
4331
0
                                                    }
4332
3.49k
                                                }
4333
                                            }
4334
                                        }
4335
17
                                        _ => {}
4336
                                    }
4337
                                }
4338
                                &InstructionData::UnaryImm {
4339
26.7k
                                    opcode: ref v14,
4340
26.7k
                                    imm: v15,
4341
                                } => {
4342
26.7k
                                    if let &Opcode::Iconst = v14 {
4343
26.7k
                                        if v2.0 == v11.0 {
4344
26.7k
                                            let mut v18 = C::inst_data_value_etor_returns::default();
4345
26.7k
                                            C::inst_data_value_etor(ctx, v7.0, &mut v18);
4346
26.7k
                                            let mut v18 = v18.into_context_iter();
4347
54.7k
                                            while let Some(
v1928.0k
) = v18.next(ctx) {
4348
                                                if let &InstructionData::Binary {
4349
5.66k
                                                    opcode: ref v122,
4350
5.66k
                                                    args: ref v123,
4351
28.0k
                                                } = &v19.1 {
4352
5.66k
                                                    match v122 {
4353
                                                        &Opcode::Band => {
4354
531
                                                            if v2.0 == v19.0 {
4355
531
                                                                let v124 = C::unpack_value_array_2(ctx, v123);
4356
531
                                                                let mut v199 = C::inst_data_value_etor_returns::default();
4357
531
                                                                C::inst_data_value_etor(ctx, v124.1, &mut v199);
4358
531
                                                                let mut v199 = v199.into_context_iter();
4359
1.06k
                                                                while let Some(
v200531
) = v199.next(ctx) {
4360
                                                                    if let &InstructionData::UnaryImm {
4361
529
                                                                        opcode: ref v241,
4362
529
                                                                        imm: v242,
4363
531
                                                                    } = &v200.1 {
4364
529
                                                                        if let &Opcode::Iconst = v241 {
4365
529
                                                                            let v244 = C::ty_mask(ctx, v2.0);
4366
529
                                                                            let v16 = C::u64_from_imm64(ctx, v15);
4367
529
                                                                            let v245 = C::u64_and(ctx, v244, v16);
4368
529
                                                                            let v243 = C::u64_from_imm64(ctx, v242);
4369
529
                                                                            let v246 = C::u64_not(ctx, v243);
4370
529
                                                                            let v247 = C::u64_and(ctx, v244, v246);
4371
529
                                                                            let v248 = C::u64_eq(ctx, v245, v247);
4372
529
                                                                            if v248 == true {
4373
0
                                                                                if v2.0 == v200.0 {
4374
0
                                                                                    let v239 = constructor_bor(ctx, v2.0, v124.0, v7.1);
4375
                                                                                    // Rule at src/opts/bitops.isle line 72.
4376
0
                                                                                    returns.extend(Some(v239));
4377
0
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
4378
0
                                                                                }
4379
529
                                                                            }
4380
0
                                                                        }
4381
2
                                                                    }
4382
                                                                }
4383
0
                                                            }
4384
                                                        }
4385
                                                        &Opcode::Bor => {
4386
6
                                                            if v2.0 == v19.0 {
4387
6
                                                                let v124 = C::unpack_value_array_2(ctx, v123);
4388
6
                                                                let mut v199 = C::inst_data_value_etor_returns::default();
4389
6
                                                                C::inst_data_value_etor(ctx, v124.1, &mut v199);
4390
6
                                                                let mut v199 = v199.into_context_iter();
4391
8
                                                                while let Some(
v2002
) = v199.next(ctx) {
4392
                                                                    if let &InstructionData::UnaryImm {
4393
0
                                                                        opcode: ref v241,
4394
0
                                                                        imm: v242,
4395
2
                                                                    } = &v200.1 {
4396
0
                                                                        if let &Opcode::Iconst = v241 {
4397
0
                                                                            if v2.0 == v200.0 {
4398
0
                                                                                let v640 = constructor_bor(ctx, v2.0, v124.1, v7.1);
4399
0
                                                                                let v641 = constructor_bor(ctx, v2.0, v124.0, v640);
4400
                                                                                // Rule at src/opts/cprop.isle line 157.
4401
0
                                                                                returns.extend(Some(v641));
4402
0
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
4403
0
                                                                            }
4404
0
                                                                        }
4405
2
                                                                    }
4406
                                                                }
4407
0
                                                            }
4408
                                                        }
4409
5.13k
                                                        _ => {}
4410
                                                    }
4411
22.3k
                                                }
4412
                                            }
4413
26.7k
                                            let v16 = C::u64_from_imm64(ctx, v15);
4414
26.7k
                                            if v16 == 0x0_u64 {
4415
57
                                                let v17 = C::subsume(ctx, v7.0);
4416
                                                // Rule at src/opts/bitops.isle line 3.
4417
57
                                                returns.extend(Some(v17));
4418
57
                                                if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
4419
26.6k
                                            }
4420
0
                                        }
4421
26.7k
                                        let v541 = C::fits_in_64(ctx, v2.0);
4422
26.7k
                                        if let Some(v542) = v541 {
4423
26.7k
                                            if v11.0 == v542 {
4424
26.7k
                                                let mut v18 = C::inst_data_value_etor_returns::default();
4425
26.7k
                                                C::inst_data_value_etor(ctx, v7.0, &mut v18);
4426
26.7k
                                                let mut v18 = v18.into_context_iter();
4427
54.7k
                                                while let Some(
v1928.0k
) = v18.next(ctx) {
4428
                                                    if let &InstructionData::UnaryImm {
4429
21.7k
                                                        opcode: ref v22,
4430
21.7k
                                                        imm: v23,
4431
28.0k
                                                    } = &v19.1 {
4432
21.7k
                                                        if let &Opcode::Iconst = v22 {
4433
21.7k
                                                            if v11.0 == v19.0 {
4434
21.7k
                                                                let v24 = C::u64_from_imm64(ctx, v23);
4435
21.7k
                                                                let v16 = C::u64_from_imm64(ctx, v15);
4436
21.7k
                                                                let v555 = C::u64_or(ctx, v24, v16);
4437
21.7k
                                                                let v556 = C::imm64_masked(ctx, v542, v555);
4438
21.7k
                                                                let v557 = constructor_iconst(ctx, v542, v556);
4439
21.7k
                                                                let v558 = C::subsume(ctx, v557);
4440
                                                                // Rule at src/opts/cprop.isle line 32.
4441
21.7k
                                                                returns.extend(Some(v558));
4442
21.7k
                                                                if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
4443
0
                                                            }
4444
0
                                                        }
4445
6.31k
                                                    }
4446
                                                }
4447
0
                                            }
4448
0
                                        }
4449
26.7k
                                        let v1142 = C::remat(ctx, arg0);
4450
                                        // Rule at src/opts/remat.isle line 17.
4451
26.7k
                                        returns.extend(Some(v1142));
4452
26.7k
                                        if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
4453
0
                                    }
4454
                                }
4455
2.08k
                                _ => {}
4456
                            }
4457
                        }
4458
40.5k
                        let mut v18 = C::inst_data_value_etor_returns::default();
4459
40.5k
                        C::inst_data_value_etor(ctx, v7.0, &mut v18);
4460
40.5k
                        let mut v18 = v18.into_context_iter();
4461
81.6k
                        while let Some(
v1941.0k
) = v18.next(ctx) {
4462
41.0k
                            match &v19.1 {
4463
                                &InstructionData::Unary {
4464
2.00k
                                    opcode: ref v29,
4465
2.00k
                                    arg: v30,
4466
                                } => {
4467
2.00k
                                    if let &Opcode::Bnot = v29 {
4468
4
                                        if v7.1 == v30 {
4469
0
                                            let v52 = C::ty_int(ctx, v2.0);
4470
0
                                            if let Some(v53) = v52 {
4471
0
                                                if v19.0 == v53 {
4472
0
                                                    let v232 = constructor_iconst_s(ctx, v53, -1_i64);
4473
0
                                                    let v233 = C::subsume(ctx, v232);
4474
                                                    // Rule at src/opts/bitops.isle line 25.
4475
0
                                                    returns.extend(Some(v233));
4476
0
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
4477
0
                                                }
4478
0
                                            }
4479
4
                                        }
4480
1.99k
                                    }
4481
                                }
4482
                                &InstructionData::UnaryImm {
4483
21.7k
                                    opcode: ref v22,
4484
21.7k
                                    imm: v23,
4485
                                } => {
4486
21.7k
                                    if let &Opcode::Iconst = v22 {
4487
21.7k
                                        if v2.0 == v19.0 {
4488
21.7k
                                            let v611 = constructor_bor(ctx, v2.0, v7.1, v7.0);
4489
                                            // Rule at src/opts/cprop.isle line 104.
4490
21.7k
                                            returns.extend(Some(v611));
4491
21.7k
                                            if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
4492
0
                                        }
4493
21.7k
                                        let v1142 = C::remat(ctx, arg0);
4494
                                        // Rule at src/opts/remat.isle line 15.
4495
21.7k
                                        returns.extend(Some(v1142));
4496
21.7k
                                        if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
4497
0
                                    }
4498
                                }
4499
17.3k
                                _ => {}
4500
                            }
4501
                        }
4502
40.5k
                        if v7.0 == v7.1 {
4503
6
                            let v17 = C::subsume(ctx, v7.0);
4504
                            // Rule at src/opts/bitops.isle line 7.
4505
6
                            returns.extend(Some(v17));
4506
6
                            if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
4507
40.5k
                        }
4508
                    }
4509
                    &Opcode::Bxor => {
4510
6.06k
                        let v7 = C::unpack_value_array_2(ctx, v6);
4511
6.06k
                        let mut v10 = C::inst_data_value_etor_returns::default();
4512
6.06k
                        C::inst_data_value_etor(ctx, v7.1, &mut v10);
4513
6.06k
                        let mut v10 = v10.into_context_iter();
4514
11.9k
                        while let Some(
v115.91k
) = v10.next(ctx) {
4515
5.91k
                            match &v11.1 {
4516
                                &InstructionData::Binary {
4517
2.20k
                                    opcode: ref v104,
4518
2.20k
                                    args: ref v105,
4519
                                } => {
4520
2.20k
                                    if let &Opcode::Bxor = v104 {
4521
1.15k
                                        if v2.0 == v11.0 {
4522
1.15k
                                            let mut v18 = C::inst_data_value_etor_returns::default();
4523
1.15k
                                            C::inst_data_value_etor(ctx, v7.0, &mut v18);
4524
1.15k
                                            let mut v18 = v18.into_context_iter();
4525
2.24k
                                            while let Some(
v191.08k
) = v18.next(ctx) {
4526
                                                if let &InstructionData::Binary {
4527
1.07k
                                                    opcode: ref v122,
4528
1.07k
                                                    args: ref v123,
4529
1.08k
                                                } = &v19.1 {
4530
1.07k
                                                    match v122 {
4531
                                                        &Opcode::Band => {
4532
25
                                                            if v2.0 == v19.0 {
4533
25
                                                                let v106 = C::unpack_value_array_2(ctx, v105);
4534
25
                                                                let v124 = C::unpack_value_array_2(ctx, v123);
4535
25
                                                                if v106.0 == v124.0 {
4536
0
                                                                    if v106.1 == v124.1 {
4537
0
                                                                        let v234 = constructor_bor(ctx, v2.0, v124.0, v124.1);
4538
                                                                        // Rule at src/opts/bitops.isle line 38.
4539
0
                                                                        returns.extend(Some(v234));
4540
0
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
4541
0
                                                                    }
4542
25
                                                                }
4543
0
                                                            }
4544
                                                        }
4545
                                                        &Opcode::Bxor => {
4546
900
                                                            if v2.0 == v19.0 {
4547
900
                                                                let v106 = C::unpack_value_array_2(ctx, v105);
4548
900
                                                                let mut v109 = C::inst_data_value_etor_returns::default();
4549
900
                                                                C::inst_data_value_etor(ctx, v106.1, &mut v109);
4550
900
                                                                let mut v109 = v109.into_context_iter();
4551
1.44k
                                                                while let Some(
v110544
) = v109.next(ctx) {
4552
                                                                    if let &InstructionData::UnaryImm {
4553
13
                                                                        opcode: ref v724,
4554
13
                                                                        imm: v725,
4555
544
                                                                    } = &v110.1 {
4556
13
                                                                        if let &Opcode::Iconst = v724 {
4557
13
                                                                            let v124 = C::unpack_value_array_2(ctx, v123);
4558
13
                                                                            let mut v199 = C::inst_data_value_etor_returns::default();
4559
13
                                                                            C::inst_data_value_etor(ctx, v124.1, &mut v199);
4560
13
                                                                            let mut v199 = v199.into_context_iter();
4561
24
                                                                            while let Some(
v20011
) = v199.next(ctx) {
4562
                                                                                if let &InstructionData::UnaryImm {
4563
0
                                                                                    opcode: ref v241,
4564
0
                                                                                    imm: v242,
4565
11
                                                                                } = &v200.1 {
4566
0
                                                                                    if let &Opcode::Iconst = v241 {
4567
0
                                                                                        let v738 = constructor_bxor(ctx, v2.0, v124.0, v106.0);
4568
0
                                                                                        let v739 = constructor_bxor(ctx, v2.0, v124.1, v106.1);
4569
0
                                                                                        let v740 = constructor_bxor(ctx, v2.0, v738, v739);
4570
                                                                                        // Rule at src/opts/cprop.isle line 257.
4571
0
                                                                                        returns.extend(Some(v740));
4572
0
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
4573
0
                                                                                    }
4574
11
                                                                                }
4575
                                                                            }
4576
0
                                                                        }
4577
531
                                                                    }
4578
                                                                }
4579
0
                                                            }
4580
                                                        }
4581
146
                                                        _ => {}
4582
                                                    }
4583
15
                                                }
4584
                                            }
4585
1.15k
                                            let v106 = C::unpack_value_array_2(ctx, v105);
4586
1.15k
                                            let mut v109 = C::inst_data_value_etor_returns::default();
4587
1.15k
                                            C::inst_data_value_etor(ctx, v106.1, &mut v109);
4588
1.15k
                                            let mut v109 = v109.into_context_iter();
4589
1.92k
                                            while let Some(
v110769
) = v109.next(ctx) {
4590
                                                if let &InstructionData::Binary {
4591
719
                                                    opcode: ref v113,
4592
719
                                                    args: ref v114,
4593
769
                                                } = &v110.1 {
4594
719
                                                    if let &Opcode::Bxor = v113 {
4595
530
                                                        if v2.0 == v110.0 {
4596
530
                                                            let v156 = constructor_bxor(ctx, v2.0, v7.0, v106.0);
4597
530
                                                            let v115 = C::unpack_value_array_2(ctx, v114);
4598
530
                                                            let v157 = constructor_bxor(ctx, v2.0, v115.0, v115.1);
4599
530
                                                            let v158 = constructor_bxor(ctx, v2.0, v156, v157);
4600
530
                                                            let v159 = C::subsume(ctx, v158);
4601
                                                            // Rule at src/opts/arithmetic.isle line 227.
4602
530
                                                            returns.extend(Some(v159));
4603
530
                                                            if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
4604
0
                                                        }
4605
189
                                                    }
4606
50
                                                }
4607
                                            }
4608
0
                                        }
4609
1.04k
                                    }
4610
                                }
4611
                                &InstructionData::Unary {
4612
243
                                    opcode: ref v26,
4613
243
                                    arg: v27,
4614
                                } => {
4615
243
                                    match v26 {
4616
                                        &Opcode::Splat => {
4617
0
                                            let v1380 = C::ty_vector_not_float(ctx, v2.0);
4618
0
                                            if let Some(v1381) = v1380 {
4619
0
                                                if v2.0 == v11.0 {
4620
0
                                                    let mut v18 = C::inst_data_value_etor_returns::default();
4621
0
                                                    C::inst_data_value_etor(ctx, v7.0, &mut v18);
4622
0
                                                    let mut v18 = v18.into_context_iter();
4623
0
                                                    while let Some(v19) = v18.next(ctx) {
4624
                                                        if let &InstructionData::Unary {
4625
0
                                                            opcode: ref v29,
4626
0
                                                            arg: v30,
4627
0
                                                        } = &v19.1 {
4628
0
                                                            if let &Opcode::Splat = v29 {
4629
0
                                                                if v2.0 == v19.0 {
4630
0
                                                                    let v1262 = C::lane_type(ctx, v2.0);
4631
0
                                                                    let v1386 = constructor_bxor(ctx, v1262, v30, v27);
4632
0
                                                                    let v1387 = constructor_splat(ctx, v2.0, v1386);
4633
                                                                    // Rule at src/opts/vector.isle line 22.
4634
0
                                                                    returns.extend(Some(v1387));
4635
0
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
4636
0
                                                                }
4637
0
                                                            }
4638
0
                                                        }
4639
                                                    }
4640
0
                                                }
4641
0
                                            }
4642
                                        }
4643
                                        &Opcode::Bnot => {
4644
13
                                            let v52 = C::ty_int(ctx, v2.0);
4645
13
                                            if let Some(v53) = v52 {
4646
13
                                                if v7.0 == v27 {
4647
0
                                                    if v11.0 == v53 {
4648
0
                                                        let v232 = constructor_iconst_s(ctx, v53, -1_i64);
4649
0
                                                        let v233 = C::subsume(ctx, v232);
4650
                                                        // Rule at src/opts/bitops.isle line 22.
4651
0
                                                        returns.extend(Some(v233));
4652
0
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
4653
0
                                                    }
4654
13
                                                }
4655
0
                                            }
4656
                                        }
4657
                                        &Opcode::Uextend => {
4658
16
                                            let mut v18 = C::inst_data_value_etor_returns::default();
4659
16
                                            C::inst_data_value_etor(ctx, v7.0, &mut v18);
4660
16
                                            let mut v18 = v18.into_context_iter();
4661
35
                                            while let Some(
v1919
) = v18.next(ctx) {
4662
                                                if let &InstructionData::Unary {
4663
7
                                                    opcode: ref v29,
4664
7
                                                    arg: v30,
4665
19
                                                } = &v19.1 {
4666
7
                                                    if let &Opcode::Uextend = v29 {
4667
7
                                                        let v939 = C::value_type(ctx, v30);
4668
7
                                                        let v974 = C::value_type(ctx, v27);
4669
7
                                                        if v939 == v974 {
4670
7
                                                            let v979 = constructor_bxor(ctx, v939, v30, v27);
4671
7
                                                            let v980 = constructor_uextend(ctx, v2.0, v979);
4672
                                                            // Rule at src/opts/extends.isle line 74.
4673
7
                                                            returns.extend(Some(v980));
4674
7
                                                            if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
4675
0
                                                        }
4676
0
                                                    }
4677
12
                                                }
4678
                                            }
4679
                                        }
4680
214
                                        _ => {}
4681
                                    }
4682
                                }
4683
                                &InstructionData::UnaryImm {
4684
2.59k
                                    opcode: ref v14,
4685
2.59k
                                    imm: v15,
4686
                                } => {
4687
2.59k
                                    if let &Opcode::Iconst = v14 {
4688
2.59k
                                        if v2.0 == v11.0 {
4689
2.59k
                                            let v16 = C::u64_from_imm64(ctx, v15);
4690
2.59k
                                            if v16 == 0x0_u64 {
4691
6
                                                let v17 = C::subsume(ctx, v7.0);
4692
                                                // Rule at src/opts/bitops.isle line 11.
4693
6
                                                returns.extend(Some(v17));
4694
6
                                                if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
4695
2.58k
                                            }
4696
2.59k
                                            let mut v18 = C::inst_data_value_etor_returns::default();
4697
2.59k
                                            C::inst_data_value_etor(ctx, v7.0, &mut v18);
4698
2.59k
                                            let mut v18 = v18.into_context_iter();
4699
4.66k
                                            while let Some(
v192.06k
) = v18.next(ctx) {
4700
                                                if let &InstructionData::Binary {
4701
1.18k
                                                    opcode: ref v122,
4702
1.18k
                                                    args: ref v123,
4703
2.06k
                                                } = &v19.1 {
4704
1.18k
                                                    if let &Opcode::Bxor = v122 {
4705
59
                                                        if v2.0 == v19.0 {
4706
59
                                                            let v124 = C::unpack_value_array_2(ctx, v123);
4707
59
                                                            let mut v199 = C::inst_data_value_etor_returns::default();
4708
59
                                                            C::inst_data_value_etor(ctx, v124.1, &mut v199);
4709
59
                                                            let mut v199 = v199.into_context_iter();
4710
115
                                                            while let Some(
v20056
) = v199.next(ctx) {
4711
                                                                if let &InstructionData::UnaryImm {
4712
0
                                                                    opcode: ref v241,
4713
0
                                                                    imm: v242,
4714
56
                                                                } = &v200.1 {
4715
0
                                                                    if let &Opcode::Iconst = v241 {
4716
0
                                                                        if v2.0 == v200.0 {
4717
0
                                                                            let v644 = constructor_bxor(ctx, v2.0, v124.1, v7.1);
4718
0
                                                                            let v645 = constructor_bxor(ctx, v2.0, v124.0, v644);
4719
                                                                            // Rule at src/opts/cprop.isle line 163.
4720
0
                                                                            returns.extend(Some(v645));
4721
0
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
4722
0
                                                                        }
4723
0
                                                                    }
4724
56
                                                                }
4725
                                                            }
4726
0
                                                        }
4727
1.12k
                                                    }
4728
884
                                                }
4729
                                            }
4730
0
                                        }
4731
2.59k
                                        let v541 = C::fits_in_64(ctx, v2.0);
4732
2.59k
                                        if let Some(v542) = v541 {
4733
2.59k
                                            if v11.0 == v542 {
4734
2.59k
                                                let mut v18 = C::inst_data_value_etor_returns::default();
4735
2.59k
                                                C::inst_data_value_etor(ctx, v7.0, &mut v18);
4736
2.59k
                                                let mut v18 = v18.into_context_iter();
4737
4.66k
                                                while let Some(
v192.06k
) = v18.next(ctx) {
4738
                                                    if let &InstructionData::UnaryImm {
4739
24
                                                        opcode: ref v22,
4740
24
                                                        imm: v23,
4741
2.06k
                                                    } = &v19.1 {
4742
24
                                                        if let &Opcode::Iconst = v22 {
4743
24
                                                            if v11.0 == v19.0 {
4744
24
                                                                let v24 = C::u64_from_imm64(ctx, v23);
4745
24
                                                                let v16 = C::u64_from_imm64(ctx, v15);
4746
24
                                                                let v563 = C::u64_xor(ctx, v24, v16);
4747
24
                                                                let v564 = C::imm64_masked(ctx, v542, v563);
4748
24
                                                                let v565 = constructor_iconst(ctx, v542, v564);
4749
24
                                                                let v566 = C::subsume(ctx, v565);
4750
                                                                // Rule at src/opts/cprop.isle line 44.
4751
24
                                                                returns.extend(Some(v566));
4752
24
                                                                if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
4753
0
                                                            }
4754
0
                                                        }
4755
2.04k
                                                    }
4756
                                                }
4757
0
                                            }
4758
0
                                        }
4759
2.59k
                                        let v1142 = C::remat(ctx, arg0);
4760
                                        // Rule at src/opts/remat.isle line 21.
4761
2.59k
                                        returns.extend(Some(v1142));
4762
2.59k
                                        if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
4763
0
                                    }
4764
                                }
4765
873
                                _ => {}
4766
                            }
4767
                        }
4768
6.06k
                        let mut v18 = C::inst_data_value_etor_returns::default();
4769
6.06k
                        C::inst_data_value_etor(ctx, v7.0, &mut v18);
4770
6.06k
                        let mut v18 = v18.into_context_iter();
4771
11.6k
                        while let Some(
v195.57k
) = v18.next(ctx) {
4772
5.57k
                            match &v19.1 {
4773
                                &InstructionData::Binary {
4774
3.72k
                                    opcode: ref v122,
4775
3.72k
                                    args: ref v123,
4776
                                } => {
4777
3.72k
                                    if let &Opcode::Bxor = v122 {
4778
1.27k
                                        if v2.0 == v19.0 {
4779
1.27k
                                            let v124 = C::unpack_value_array_2(ctx, v123);
4780
1.27k
                                            let mut v127 = C::inst_data_value_etor_returns::default();
4781
1.27k
                                            C::inst_data_value_etor(ctx, v124.0, &mut v127);
4782
1.27k
                                            let mut v127 = v127.into_context_iter();
4783
2.28k
                                            while let Some(
v1281.00k
) = v127.next(ctx) {
4784
                                                if let &InstructionData::Binary {
4785
847
                                                    opcode: ref v131,
4786
847
                                                    args: ref v132,
4787
1.00k
                                                } = &v128.1 {
4788
847
                                                    if let &Opcode::Bxor = v131 {
4789
540
                                                        if v2.0 == v128.0 {
4790
540
                                                            let v133 = C::unpack_value_array_2(ctx, v132);
4791
540
                                                            let v160 = constructor_bxor(ctx, v2.0, v133.0, v133.1);
4792
540
                                                            let v161 = constructor_bxor(ctx, v2.0, v124.1, v7.1);
4793
540
                                                            let v162 = constructor_bxor(ctx, v2.0, v160, v161);
4794
540
                                                            let v163 = C::subsume(ctx, v162);
4795
                                                            // Rule at src/opts/arithmetic.isle line 229.
4796
540
                                                            returns.extend(Some(v163));
4797
540
                                                            if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
4798
0
                                                        }
4799
307
                                                    }
4800
162
                                                }
4801
                                            }
4802
0
                                        }
4803
2.45k
                                    }
4804
                                }
4805
                                &InstructionData::Unary {
4806
242
                                    opcode: ref v29,
4807
242
                                    arg: v30,
4808
                                } => {
4809
242
                                    if let &Opcode::Bnot = v29 {
4810
0
                                        if v7.1 == v30 {
4811
0
                                            let v52 = C::ty_int(ctx, v2.0);
4812
0
                                            if let Some(v53) = v52 {
4813
0
                                                if v19.0 == v53 {
4814
0
                                                    let v232 = constructor_iconst_s(ctx, v53, -1_i64);
4815
0
                                                    let v233 = C::subsume(ctx, v232);
4816
                                                    // Rule at src/opts/bitops.isle line 23.
4817
0
                                                    returns.extend(Some(v233));
4818
0
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
4819
0
                                                }
4820
0
                                            }
4821
0
                                        }
4822
242
                                    }
4823
                                }
4824
                                &InstructionData::UnaryImm {
4825
24
                                    opcode: ref v22,
4826
24
                                    imm: v23,
4827
                                } => {
4828
24
                                    if let &Opcode::Iconst = v22 {
4829
24
                                        if v2.0 == v19.0 {
4830
24
                                            let v613 = constructor_bxor(ctx, v2.0, v7.1, v7.0);
4831
                                            // Rule at src/opts/cprop.isle line 110.
4832
24
                                            returns.extend(Some(v613));
4833
24
                                            if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
4834
0
                                        }
4835
24
                                        let v1142 = C::remat(ctx, arg0);
4836
                                        // Rule at src/opts/remat.isle line 19.
4837
24
                                        returns.extend(Some(v1142));
4838
24
                                        if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
4839
0
                                    }
4840
                                }
4841
1.58k
                                _ => {}
4842
                            }
4843
                        }
4844
6.06k
                        if v7.0 == v7.1 {
4845
12
                            let v52 = C::ty_int(ctx, v2.0);
4846
12
                            if let Some(v53) = v52 {
4847
12
                                let v55 = constructor_iconst_u(ctx, v53, 0x0_u64);
4848
12
                                let v56 = C::subsume(ctx, v55);
4849
                                // Rule at src/opts/bitops.isle line 17.
4850
12
                                returns.extend(Some(v56));
4851
12
                                if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
4852
0
                            }
4853
6.05k
                        }
4854
6.06k
                        let mut v58 = C::inst_data_value_tupled_etor_returns::default();
4855
6.06k
                        C::inst_data_value_tupled_etor(ctx, v7.1, &mut v58);
4856
6.06k
                        let mut v58 = v58.into_context_iter();
4857
11.9k
                        while let Some(
v595.91k
) = v58.next(ctx) {
4858
5.91k
                            let v60 = C::iconst_sextend_etor(ctx, v59);
4859
5.91k
                            if let Some(
v612.59k
) = v60 {
4860
2.59k
                                if v61.1 == -1_i64 {
4861
1.50k
                                    if v2.0 == v61.0 {
4862
1.50k
                                        let v249 = constructor_bnot(ctx, v2.0, v7.0);
4863
                                        // Rule at src/opts/bitops.isle line 80.
4864
1.50k
                                        returns.extend(Some(v249));
4865
1.50k
                                        if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
4866
0
                                    }
4867
1.09k
                                }
4868
3.31k
                            }
4869
                        }
4870
                    }
4871
                    &Opcode::Rotl => {
4872
962
                        let v7 = C::unpack_value_array_2(ctx, v6);
4873
962
                        let mut v10 = C::inst_data_value_etor_returns::default();
4874
962
                        C::inst_data_value_etor(ctx, v7.1, &mut v10);
4875
962
                        let mut v10 = v10.into_context_iter();
4876
1.91k
                        while let Some(
v11953
) = v10.next(ctx) {
4877
953
                            match &v11.1 {
4878
                                &InstructionData::Binary {
4879
48
                                    opcode: ref v104,
4880
48
                                    args: ref v105,
4881
                                } => {
4882
48
                                    if let &Opcode::Iconcat = v104 {
4883
0
                                        let v106 = C::unpack_value_array_2(ctx, v105);
4884
0
                                        let v1258 = constructor_rotl(ctx, v2.0, v7.0, v106.0);
4885
                                        // Rule at src/opts/shifts.isle line 142.
4886
0
                                        returns.extend(Some(v1258));
4887
0
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
4888
48
                                    }
4889
                                }
4890
                                &InstructionData::Unary {
4891
0
                                    opcode: ref v26,
4892
0
                                    arg: v27,
4893
                                } => {
4894
0
                                    match v26 {
4895
                                        &Opcode::Ireduce => {
4896
0
                                            let v974 = C::value_type(ctx, v27);
4897
0
                                            let v1247 = C::fits_in_64(ctx, v974);
4898
0
                                            if let Some(v1248) = v1247 {
4899
0
                                                let v1253 = constructor_rotl(ctx, v2.0, v7.0, v27);
4900
                                                // Rule at src/opts/shifts.isle line 126.
4901
0
                                                returns.extend(Some(v1253));
4902
0
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
4903
0
                                            }
4904
                                        }
4905
                                        &Opcode::Uextend => {
4906
0
                                            let v1253 = constructor_rotl(ctx, v2.0, v7.0, v27);
4907
                                            // Rule at src/opts/shifts.isle line 127.
4908
0
                                            returns.extend(Some(v1253));
4909
0
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
4910
                                        }
4911
                                        &Opcode::Sextend => {
4912
0
                                            let v1253 = constructor_rotl(ctx, v2.0, v7.0, v27);
4913
                                            // Rule at src/opts/shifts.isle line 128.
4914
0
                                            returns.extend(Some(v1253));
4915
0
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
4916
                                        }
4917
0
                                        _ => {}
4918
                                    }
4919
                                }
4920
                                &InstructionData::UnaryImm {
4921
898
                                    opcode: ref v14,
4922
898
                                    imm: v15,
4923
                                } => {
4924
898
                                    if let &Opcode::Iconst = v14 {
4925
898
                                        let mut v18 = C::inst_data_value_etor_returns::default();
4926
898
                                        C::inst_data_value_etor(ctx, v7.0, &mut v18);
4927
898
                                        let mut v18 = v18.into_context_iter();
4928
1.98k
                                        while let Some(
v191.09k
) = v18.next(ctx) {
4929
                                            if let &InstructionData::Binary {
4930
637
                                                opcode: ref v122,
4931
637
                                                args: ref v123,
4932
1.09k
                                            } = &v19.1 {
4933
637
                                                match v122 {
4934
                                                    &Opcode::Rotl => {
4935
0
                                                        if v2.0 == v19.0 {
4936
0
                                                            let v124 = C::unpack_value_array_2(ctx, v123);
4937
0
                                                            let v1271 = constructor_iadd_uextend(ctx, v124.1, v7.1);
4938
0
                                                            let v1272 = constructor_rotl(ctx, v2.0, v124.0, v1271);
4939
                                                            // Rule at src/opts/shifts.isle line 239.
4940
0
                                                            returns.extend(Some(v1272));
4941
0
                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
4942
0
                                                        }
4943
                                                    }
4944
                                                    &Opcode::Rotr => {
4945
0
                                                        if v2.0 == v19.0 {
4946
0
                                                            let v124 = C::unpack_value_array_2(ctx, v123);
4947
0
                                                            let v1274 = constructor_isub_uextend(ctx, v124.1, v7.1);
4948
0
                                                            let v1276 = constructor_rotr(ctx, v2.0, v124.0, v1274);
4949
                                                            // Rule at src/opts/shifts.isle line 246.
4950
0
                                                            returns.extend(Some(v1276));
4951
0
                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
4952
0
                                                        }
4953
                                                    }
4954
637
                                                    _ => {}
4955
                                                }
4956
453
                                            }
4957
                                        }
4958
898
                                        let v16 = C::u64_from_imm64(ctx, v15);
4959
898
                                        if v16 == 0x0_u64 {
4960
0
                                            if v2.0 == v11.0 {
4961
0
                                                let v17 = C::subsume(ctx, v7.0);
4962
                                                // Rule at src/opts/shifts.isle line 19.
4963
0
                                                returns.extend(Some(v17));
4964
0
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
4965
0
                                            }
4966
898
                                        }
4967
898
                                        let v250 = constructor_ty_shift_mask(ctx, v2.0);
4968
898
                                        let v1260 = C::u64_and(ctx, v16, v250);
4969
898
                                        let v1287 = C::u64_eq(ctx, v16, v1260);
4970
898
                                        if v1287 == false {
4971
0
                                            let v1288 = constructor_iconst_u(ctx, v11.0, v1260);
4972
0
                                            let v1293 = constructor_rotl(ctx, v2.0, v7.0, v1288);
4973
                                            // Rule at src/opts/shifts.isle line 304.
4974
0
                                            returns.extend(Some(v1293));
4975
0
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
4976
898
                                        }
4977
0
                                    }
4978
                                }
4979
7
                                _ => {}
4980
                            }
4981
                        }
4982
962
                        let mut v18 = C::inst_data_value_etor_returns::default();
4983
962
                        C::inst_data_value_etor(ctx, v7.0, &mut v18);
4984
962
                        let mut v18 = v18.into_context_iter();
4985
2.11k
                        while let Some(
v191.15k
) = v18.next(ctx) {
4986
1.15k
                            match &v19.1 {
4987
                                &InstructionData::Binary {
4988
691
                                    opcode: ref v122,
4989
691
                                    args: ref v123,
4990
                                } => {
4991
691
                                    match v122 {
4992
                                        &Opcode::Rotl => {
4993
0
                                            if v2.0 == v19.0 {
4994
0
                                                let v124 = C::unpack_value_array_2(ctx, v123);
4995
0
                                                let v1277 = C::value_type(ctx, v124.1);
4996
0
                                                let v1278 = C::value_type(ctx, v7.1);
4997
0
                                                if v1277 == v1278 {
4998
0
                                                    let v1271 = constructor_iadd_uextend(ctx, v124.1, v7.1);
4999
0
                                                    let v1272 = constructor_rotl(ctx, v2.0, v124.0, v1271);
5000
                                                    // Rule at src/opts/shifts.isle line 260.
5001
0
                                                    returns.extend(Some(v1272));
5002
0
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
5003
0
                                                }
5004
0
                                                let mut v199 = C::inst_data_value_etor_returns::default();
5005
0
                                                C::inst_data_value_etor(ctx, v124.1, &mut v199);
5006
0
                                                let mut v199 = v199.into_context_iter();
5007
0
                                                while let Some(v200) = v199.next(ctx) {
5008
                                                    if let &InstructionData::UnaryImm {
5009
0
                                                        opcode: ref v241,
5010
0
                                                        imm: v242,
5011
0
                                                    } = &v200.1 {
5012
0
                                                        if let &Opcode::Iconst = v241 {
5013
0
                                                            let v1271 = constructor_iadd_uextend(ctx, v124.1, v7.1);
5014
0
                                                            let v1272 = constructor_rotl(ctx, v2.0, v124.0, v1271);
5015
                                                            // Rule at src/opts/shifts.isle line 238.
5016
0
                                                            returns.extend(Some(v1272));
5017
0
                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
5018
0
                                                        }
5019
0
                                                    }
5020
                                                }
5021
0
                                            }
5022
                                        }
5023
                                        &Opcode::Rotr => {
5024
0
                                            if v2.0 == v19.0 {
5025
0
                                                let v124 = C::unpack_value_array_2(ctx, v123);
5026
0
                                                if v7.1 == v124.1 {
5027
0
                                                    let v1270 = C::subsume(ctx, v124.0);
5028
                                                    // Rule at src/opts/shifts.isle line 203.
5029
0
                                                    returns.extend(Some(v1270));
5030
0
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
5031
0
                                                }
5032
0
                                                let v1277 = C::value_type(ctx, v124.1);
5033
0
                                                let v1278 = C::value_type(ctx, v7.1);
5034
0
                                                if v1277 == v1278 {
5035
0
                                                    let v1274 = constructor_isub_uextend(ctx, v124.1, v7.1);
5036
0
                                                    let v1276 = constructor_rotr(ctx, v2.0, v124.0, v1274);
5037
                                                    // Rule at src/opts/shifts.isle line 265.
5038
0
                                                    returns.extend(Some(v1276));
5039
0
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
5040
0
                                                }
5041
0
                                                let mut v199 = C::inst_data_value_etor_returns::default();
5042
0
                                                C::inst_data_value_etor(ctx, v124.1, &mut v199);
5043
0
                                                let mut v199 = v199.into_context_iter();
5044
0
                                                while let Some(v200) = v199.next(ctx) {
5045
                                                    if let &InstructionData::UnaryImm {
5046
0
                                                        opcode: ref v241,
5047
0
                                                        imm: v242,
5048
0
                                                    } = &v200.1 {
5049
0
                                                        if let &Opcode::Iconst = v241 {
5050
0
                                                            let v1274 = constructor_isub_uextend(ctx, v124.1, v7.1);
5051
0
                                                            let v1276 = constructor_rotr(ctx, v2.0, v124.0, v1274);
5052
                                                            // Rule at src/opts/shifts.isle line 245.
5053
0
                                                            returns.extend(Some(v1276));
5054
0
                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
5055
0
                                                        }
5056
0
                                                    }
5057
                                                }
5058
0
                                            }
5059
                                        }
5060
691
                                        _ => {}
5061
                                    }
5062
                                }
5063
                                &InstructionData::Unary {
5064
384
                                    opcode: ref v29,
5065
384
                                    arg: v30,
5066
                                } => {
5067
384
                                    if let &Opcode::Splat = v29 {
5068
0
                                        if v2.0 == v19.0 {
5069
0
                                            let v1262 = C::lane_type(ctx, v2.0);
5070
0
                                            let v1414 = constructor_rotl(ctx, v1262, v30, v7.1);
5071
0
                                            let v1415 = constructor_splat(ctx, v2.0, v1414);
5072
                                            // Rule at src/opts/vector.isle line 68.
5073
0
                                            returns.extend(Some(v1415));
5074
0
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
5075
0
                                        }
5076
384
                                    }
5077
                                }
5078
79
                                _ => {}
5079
                            }
5080
                        }
5081
                    }
5082
                    &Opcode::Rotr => {
5083
25
                        let v7 = C::unpack_value_array_2(ctx, v6);
5084
25
                        let mut v10 = C::inst_data_value_etor_returns::default();
5085
25
                        C::inst_data_value_etor(ctx, v7.1, &mut v10);
5086
25
                        let mut v10 = v10.into_context_iter();
5087
50
                        while let Some(
v1125
) = v10.next(ctx) {
5088
25
                            match &v11.1 {
5089
                                &InstructionData::Binary {
5090
0
                                    opcode: ref v104,
5091
0
                                    args: ref v105,
5092
                                } => {
5093
0
                                    if let &Opcode::Iconcat = v104 {
5094
0
                                        let v106 = C::unpack_value_array_2(ctx, v105);
5095
0
                                        let v1257 = constructor_rotr(ctx, v2.0, v7.0, v106.0);
5096
                                        // Rule at src/opts/shifts.isle line 141.
5097
0
                                        returns.extend(Some(v1257));
5098
0
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
5099
0
                                    }
5100
                                }
5101
                                &InstructionData::Unary {
5102
0
                                    opcode: ref v26,
5103
0
                                    arg: v27,
5104
                                } => {
5105
0
                                    match v26 {
5106
                                        &Opcode::Ireduce => {
5107
0
                                            let v974 = C::value_type(ctx, v27);
5108
0
                                            let v1247 = C::fits_in_64(ctx, v974);
5109
0
                                            if let Some(v1248) = v1247 {
5110
0
                                                let v1252 = constructor_rotr(ctx, v2.0, v7.0, v27);
5111
                                                // Rule at src/opts/shifts.isle line 123.
5112
0
                                                returns.extend(Some(v1252));
5113
0
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
5114
0
                                            }
5115
                                        }
5116
                                        &Opcode::Uextend => {
5117
0
                                            let v1252 = constructor_rotr(ctx, v2.0, v7.0, v27);
5118
                                            // Rule at src/opts/shifts.isle line 124.
5119
0
                                            returns.extend(Some(v1252));
5120
0
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
5121
                                        }
5122
                                        &Opcode::Sextend => {
5123
0
                                            let v1252 = constructor_rotr(ctx, v2.0, v7.0, v27);
5124
                                            // Rule at src/opts/shifts.isle line 125.
5125
0
                                            returns.extend(Some(v1252));
5126
0
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
5127
                                        }
5128
0
                                        _ => {}
5129
                                    }
5130
                                }
5131
                                &InstructionData::UnaryImm {
5132
25
                                    opcode: ref v14,
5133
25
                                    imm: v15,
5134
                                } => {
5135
25
                                    if let &Opcode::Iconst = v14 {
5136
25
                                        let mut v18 = C::inst_data_value_etor_returns::default();
5137
25
                                        C::inst_data_value_etor(ctx, v7.0, &mut v18);
5138
25
                                        let mut v18 = v18.into_context_iter();
5139
50
                                        while let Some(
v1925
) = v18.next(ctx) {
5140
                                            if let &InstructionData::Binary {
5141
0
                                                opcode: ref v122,
5142
0
                                                args: ref v123,
5143
25
                                            } = &v19.1 {
5144
0
                                                match v122 {
5145
                                                    &Opcode::Rotl => {
5146
0
                                                        if v2.0 == v19.0 {
5147
0
                                                            let v124 = C::unpack_value_array_2(ctx, v123);
5148
0
                                                            let v1274 = constructor_isub_uextend(ctx, v124.1, v7.1);
5149
0
                                                            let v1275 = constructor_rotl(ctx, v2.0, v124.0, v1274);
5150
                                                            // Rule at src/opts/shifts.isle line 244.
5151
0
                                                            returns.extend(Some(v1275));
5152
0
                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
5153
0
                                                        }
5154
                                                    }
5155
                                                    &Opcode::Rotr => {
5156
0
                                                        if v2.0 == v19.0 {
5157
0
                                                            let v124 = C::unpack_value_array_2(ctx, v123);
5158
0
                                                            let v1271 = constructor_iadd_uextend(ctx, v124.1, v7.1);
5159
0
                                                            let v1273 = constructor_rotr(ctx, v2.0, v124.0, v1271);
5160
                                                            // Rule at src/opts/shifts.isle line 241.
5161
0
                                                            returns.extend(Some(v1273));
5162
0
                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
5163
0
                                                        }
5164
                                                    }
5165
0
                                                    _ => {}
5166
                                                }
5167
25
                                            }
5168
                                        }
5169
25
                                        let v16 = C::u64_from_imm64(ctx, v15);
5170
25
                                        if v16 == 0x0_u64 {
5171
0
                                            if v2.0 == v11.0 {
5172
0
                                                let v17 = C::subsume(ctx, v7.0);
5173
                                                // Rule at src/opts/shifts.isle line 15.
5174
0
                                                returns.extend(Some(v17));
5175
0
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
5176
0
                                            }
5177
25
                                        }
5178
25
                                        let v250 = constructor_ty_shift_mask(ctx, v2.0);
5179
25
                                        let v1260 = C::u64_and(ctx, v16, v250);
5180
25
                                        let v1287 = C::u64_eq(ctx, v16, v1260);
5181
25
                                        if v1287 == false {
5182
0
                                            let v1288 = constructor_iconst_u(ctx, v11.0, v1260);
5183
0
                                            let v1292 = constructor_rotr(ctx, v2.0, v7.0, v1288);
5184
                                            // Rule at src/opts/shifts.isle line 301.
5185
0
                                            returns.extend(Some(v1292));
5186
0
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
5187
25
                                        }
5188
0
                                    }
5189
                                }
5190
0
                                _ => {}
5191
                            }
5192
                        }
5193
25
                        let mut v18 = C::inst_data_value_etor_returns::default();
5194
25
                        C::inst_data_value_etor(ctx, v7.0, &mut v18);
5195
25
                        let mut v18 = v18.into_context_iter();
5196
50
                        while let Some(
v1925
) = v18.next(ctx) {
5197
25
                            match &v19.1 {
5198
                                &InstructionData::Binary {
5199
0
                                    opcode: ref v122,
5200
0
                                    args: ref v123,
5201
                                } => {
5202
0
                                    match v122 {
5203
                                        &Opcode::Rotl => {
5204
0
                                            if v2.0 == v19.0 {
5205
0
                                                let v124 = C::unpack_value_array_2(ctx, v123);
5206
0
                                                if v7.1 == v124.1 {
5207
0
                                                    let v1270 = C::subsume(ctx, v124.0);
5208
                                                    // Rule at src/opts/shifts.isle line 204.
5209
0
                                                    returns.extend(Some(v1270));
5210
0
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
5211
0
                                                }
5212
0
                                                let v1277 = C::value_type(ctx, v124.1);
5213
0
                                                let v1278 = C::value_type(ctx, v7.1);
5214
0
                                                if v1277 == v1278 {
5215
0
                                                    let v1274 = constructor_isub_uextend(ctx, v124.1, v7.1);
5216
0
                                                    let v1275 = constructor_rotl(ctx, v2.0, v124.0, v1274);
5217
                                                    // Rule at src/opts/shifts.isle line 263.
5218
0
                                                    returns.extend(Some(v1275));
5219
0
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
5220
0
                                                }
5221
0
                                                let mut v199 = C::inst_data_value_etor_returns::default();
5222
0
                                                C::inst_data_value_etor(ctx, v124.1, &mut v199);
5223
0
                                                let mut v199 = v199.into_context_iter();
5224
0
                                                while let Some(v200) = v199.next(ctx) {
5225
                                                    if let &InstructionData::UnaryImm {
5226
0
                                                        opcode: ref v241,
5227
0
                                                        imm: v242,
5228
0
                                                    } = &v200.1 {
5229
0
                                                        if let &Opcode::Iconst = v241 {
5230
0
                                                            let v1274 = constructor_isub_uextend(ctx, v124.1, v7.1);
5231
0
                                                            let v1275 = constructor_rotl(ctx, v2.0, v124.0, v1274);
5232
                                                            // Rule at src/opts/shifts.isle line 243.
5233
0
                                                            returns.extend(Some(v1275));
5234
0
                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
5235
0
                                                        }
5236
0
                                                    }
5237
                                                }
5238
0
                                            }
5239
                                        }
5240
                                        &Opcode::Rotr => {
5241
0
                                            if v2.0 == v19.0 {
5242
0
                                                let v124 = C::unpack_value_array_2(ctx, v123);
5243
0
                                                let v1277 = C::value_type(ctx, v124.1);
5244
0
                                                let v1278 = C::value_type(ctx, v7.1);
5245
0
                                                if v1277 == v1278 {
5246
0
                                                    let v1271 = constructor_iadd_uextend(ctx, v124.1, v7.1);
5247
0
                                                    let v1273 = constructor_rotr(ctx, v2.0, v124.0, v1271);
5248
                                                    // Rule at src/opts/shifts.isle line 258.
5249
0
                                                    returns.extend(Some(v1273));
5250
0
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
5251
0
                                                }
5252
0
                                                let mut v199 = C::inst_data_value_etor_returns::default();
5253
0
                                                C::inst_data_value_etor(ctx, v124.1, &mut v199);
5254
0
                                                let mut v199 = v199.into_context_iter();
5255
0
                                                while let Some(v200) = v199.next(ctx) {
5256
                                                    if let &InstructionData::UnaryImm {
5257
0
                                                        opcode: ref v241,
5258
0
                                                        imm: v242,
5259
0
                                                    } = &v200.1 {
5260
0
                                                        if let &Opcode::Iconst = v241 {
5261
0
                                                            let v1271 = constructor_iadd_uextend(ctx, v124.1, v7.1);
5262
0
                                                            let v1273 = constructor_rotr(ctx, v2.0, v124.0, v1271);
5263
                                                            // Rule at src/opts/shifts.isle line 240.
5264
0
                                                            returns.extend(Some(v1273));
5265
0
                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
5266
0
                                                        }
5267
0
                                                    }
5268
                                                }
5269
0
                                            }
5270
                                        }
5271
0
                                        _ => {}
5272
                                    }
5273
                                }
5274
                                &InstructionData::Unary {
5275
0
                                    opcode: ref v29,
5276
0
                                    arg: v30,
5277
                                } => {
5278
0
                                    if let &Opcode::Splat = v29 {
5279
0
                                        if v2.0 == v19.0 {
5280
0
                                            let v1262 = C::lane_type(ctx, v2.0);
5281
0
                                            let v1416 = constructor_rotr(ctx, v1262, v30, v7.1);
5282
0
                                            let v1417 = constructor_splat(ctx, v2.0, v1416);
5283
                                            // Rule at src/opts/vector.isle line 71.
5284
0
                                            returns.extend(Some(v1417));
5285
0
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
5286
0
                                        }
5287
0
                                    }
5288
                                }
5289
25
                                _ => {}
5290
                            }
5291
                        }
5292
                    }
5293
                    &Opcode::Ishl => {
5294
59.0k
                        let v7 = C::unpack_value_array_2(ctx, v6);
5295
59.0k
                        let mut v10 = C::inst_data_value_etor_returns::default();
5296
59.0k
                        C::inst_data_value_etor(ctx, v7.1, &mut v10);
5297
59.0k
                        let mut v10 = v10.into_context_iter();
5298
118k
                        while let Some(
v1159.0k
) = v10.next(ctx) {
5299
59.0k
                            match &v11.1 {
5300
                                &InstructionData::Binary {
5301
363
                                    opcode: ref v104,
5302
363
                                    args: ref v105,
5303
                                } => {
5304
363
                                    if let &Opcode::Iconcat = v104 {
5305
0
                                        let v106 = C::unpack_value_array_2(ctx, v105);
5306
0
                                        let v1254 = constructor_ishl(ctx, v2.0, v7.0, v106.0);
5307
                                        // Rule at src/opts/shifts.isle line 138.
5308
0
                                        returns.extend(Some(v1254));
5309
0
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
5310
363
                                    }
5311
                                }
5312
                                &InstructionData::Unary {
5313
189
                                    opcode: ref v26,
5314
189
                                    arg: v27,
5315
                                } => {
5316
189
                                    match v26 {
5317
                                        &Opcode::Ireduce => {
5318
0
                                            let v974 = C::value_type(ctx, v27);
5319
0
                                            let v1247 = C::fits_in_64(ctx, v974);
5320
0
                                            if let Some(v1248) = v1247 {
5321
0
                                                let v1249 = constructor_ishl(ctx, v2.0, v7.0, v27);
5322
                                                // Rule at src/opts/shifts.isle line 114.
5323
0
                                                returns.extend(Some(v1249));
5324
0
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
5325
0
                                            }
5326
                                        }
5327
                                        &Opcode::Uextend => {
5328
167
                                            let v1249 = constructor_ishl(ctx, v2.0, v7.0, v27);
5329
                                            // Rule at src/opts/shifts.isle line 115.
5330
167
                                            returns.extend(Some(v1249));
5331
167
                                            if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
5332
                                        }
5333
                                        &Opcode::Sextend => {
5334
0
                                            let v1249 = constructor_ishl(ctx, v2.0, v7.0, v27);
5335
                                            // Rule at src/opts/shifts.isle line 116.
5336
0
                                            returns.extend(Some(v1249));
5337
0
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
5338
                                        }
5339
22
                                        _ => {}
5340
                                    }
5341
                                }
5342
                                &InstructionData::UnaryImm {
5343
58.4k
                                    opcode: ref v14,
5344
58.4k
                                    imm: v15,
5345
                                } => {
5346
58.4k
                                    if let &Opcode::Iconst = v14 {
5347
58.4k
                                        let mut v18 = C::inst_data_value_etor_returns::default();
5348
58.4k
                                        C::inst_data_value_etor(ctx, v7.0, &mut v18);
5349
58.4k
                                        let mut v18 = v18.into_context_iter();
5350
114k
                                        while let Some(
v1955.6k
) = v18.next(ctx) {
5351
55.6k
                                            match &v19.1 {
5352
                                                &InstructionData::Binary {
5353
9.92k
                                                    opcode: ref v122,
5354
9.92k
                                                    args: ref v123,
5355
                                                } => {
5356
9.92k
                                                    match v122 {
5357
                                                        &Opcode::Ishl => {
5358
8
                                                            if v2.0 == v19.0 {
5359
8
                                                                let v124 = C::unpack_value_array_2(ctx, v123);
5360
8
                                                                let mut v199 = C::inst_data_value_etor_returns::default();
5361
8
                                                                C::inst_data_value_etor(ctx, v124.1, &mut v199);
5362
8
                                                                let mut v199 = v199.into_context_iter();
5363
16
                                                                while let Some(
v2008
) = v199.next(ctx) {
5364
                                                                    if let &InstructionData::UnaryImm {
5365
8
                                                                        opcode: ref v241,
5366
8
                                                                        imm: v242,
5367
8
                                                                    } = &v200.1 {
5368
8
                                                                        if let &Opcode::Iconst = v241 {
5369
8
                                                                            let v243 = C::u64_from_imm64(ctx, v242);
5370
8
                                                                            let v250 = constructor_ty_shift_mask(ctx, v2.0);
5371
8
                                                                            let v1259 = C::u64_and(ctx, v243, v250);
5372
8
                                                                            let v16 = C::u64_from_imm64(ctx, v15);
5373
8
                                                                            let v1260 = C::u64_and(ctx, v16, v250);
5374
8
                                                                            let v1261 = C::u64_wrapping_add(ctx, v1259, v1260);
5375
8
                                                                            let v1262 = C::lane_type(ctx, v2.0);
5376
8
                                                                            let v1263 = C::ty_bits_u64(ctx, v1262);
5377
8
                                                                            let v1264 = C::u64_lt(ctx, v1261, v1263);
5378
8
                                                                            if v1264 == true {
5379
8
                                                                                let v1265 = constructor_iconst_u(ctx, v200.0, v1261);
5380
8
                                                                                let v1266 = constructor_ishl(ctx, v2.0, v124.0, v1265);
5381
                                                                                // Rule at src/opts/shifts.isle line 151.
5382
8
                                                                                returns.extend(Some(v1266));
5383
8
                                                                                if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
5384
0
                                                                            }
5385
8
                                                                            let v1222 = C::ty_bits_u64(ctx, v2.0);
5386
8
                                                                            let v1269 = C::u64_lt_eq(ctx, v1222, v1261);
5387
8
                                                                            if v1269 == true {
5388
0
                                                                                let v948 = constructor_iconst_u(ctx, v2.0, 0x0_u64);
5389
0
                                                                                let v949 = C::subsume(ctx, v948);
5390
                                                                                // Rule at src/opts/shifts.isle line 183.
5391
0
                                                                                returns.extend(Some(v949));
5392
0
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
5393
8
                                                                            }
5394
0
                                                                        }
5395
0
                                                                    }
5396
                                                                }
5397
8
                                                                let mut v127 = C::inst_data_value_etor_returns::default();
5398
8
                                                                C::inst_data_value_etor(ctx, v124.0, &mut v127);
5399
8
                                                                let mut v127 = v127.into_context_iter();
5400
14
                                                                while let Some(
v1286
) = v127.next(ctx) {
5401
                                                                    if let &InstructionData::UnaryImm {
5402
0
                                                                        opcode: ref v622,
5403
0
                                                                        imm: v623,
5404
6
                                                                    } = &v128.1 {
5405
0
                                                                        if let &Opcode::Iconst = v622 {
5406
0
                                                                            let v718 = constructor_ishl(ctx, v2.0, v124.0, v7.1);
5407
0
                                                                            let v719 = constructor_ishl(ctx, v2.0, v718, v124.1);
5408
                                                                            // Rule at src/opts/cprop.isle line 228.
5409
0
                                                                            returns.extend(Some(v719));
5410
0
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
5411
0
                                                                        }
5412
6
                                                                    }
5413
                                                                }
5414
0
                                                            }
5415
                                                        }
5416
                                                        &Opcode::Ushr => {
5417
286
                                                            let v541 = C::fits_in_64(ctx, v2.0);
5418
286
                                                            if let Some(v542) = v541 {
5419
286
                                                                if v19.0 == v542 {
5420
286
                                                                    let v124 = C::unpack_value_array_2(ctx, v123);
5421
286
                                                                    let mut v199 = C::inst_data_value_etor_returns::default();
5422
286
                                                                    C::inst_data_value_etor(ctx, v124.1, &mut v199);
5423
286
                                                                    let mut v199 = v199.into_context_iter();
5424
572
                                                                    while let Some(
v200286
) = v199.next(ctx) {
5425
                                                                        if let &InstructionData::UnaryImm {
5426
286
                                                                            opcode: ref v241,
5427
286
                                                                            imm: v242,
5428
286
                                                                        } = &v200.1 {
5429
286
                                                                            if let &Opcode::Iconst = v241 {
5430
286
                                                                                if v15 == v242 {
5431
15
                                                                                    let v1213 = C::imm64(ctx, 0xffffffffffffffff_u64);
5432
15
                                                                                    let v1214 = C::imm64_shl(ctx, v542, v1213, v242);
5433
15
                                                                                    let v1215 = constructor_iconst(ctx, v542, v1214);
5434
15
                                                                                    let v1216 = constructor_band(ctx, v542, v124.0, v1215);
5435
                                                                                    // Rule at src/opts/shifts.isle line 26.
5436
15
                                                                                    returns.extend(Some(v1216));
5437
15
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
5438
271
                                                                                }
5439
0
                                                                            }
5440
0
                                                                        }
5441
                                                                    }
5442
0
                                                                }
5443
0
                                                            }
5444
                                                        }
5445
                                                        &Opcode::Sshr => {
5446
200
                                                            let v541 = C::fits_in_64(ctx, v2.0);
5447
200
                                                            if let Some(v542) = v541 {
5448
200
                                                                if v19.0 == v542 {
5449
200
                                                                    let v124 = C::unpack_value_array_2(ctx, v123);
5450
200
                                                                    let mut v199 = C::inst_data_value_etor_returns::default();
5451
200
                                                                    C::inst_data_value_etor(ctx, v124.1, &mut v199);
5452
200
                                                                    let mut v199 = v199.into_context_iter();
5453
400
                                                                    while let Some(
v200200
) = v199.next(ctx) {
5454
                                                                        if let &InstructionData::UnaryImm {
5455
200
                                                                            opcode: ref v241,
5456
200
                                                                            imm: v242,
5457
200
                                                                        } = &v200.1 {
5458
200
                                                                            if let &Opcode::Iconst = v241 {
5459
200
                                                                                if v15 == v242 {
5460
40
                                                                                    let v1213 = C::imm64(ctx, 0xffffffffffffffff_u64);
5461
40
                                                                                    let v1214 = C::imm64_shl(ctx, v542, v1213, v242);
5462
40
                                                                                    let v1215 = constructor_iconst(ctx, v542, v1214);
5463
40
                                                                                    let v1216 = constructor_band(ctx, v542, v124.0, v1215);
5464
                                                                                    // Rule at src/opts/shifts.isle line 31.
5465
40
                                                                                    returns.extend(Some(v1216));
5466
40
                                                                                    if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
5467
160
                                                                                }
5468
0
                                                                            }
5469
0
                                                                        }
5470
                                                                    }
5471
0
                                                                }
5472
0
                                                            }
5473
                                                        }
5474
9.43k
                                                        _ => {}
5475
                                                    }
5476
                                                }
5477
                                                &InstructionData::UnaryImm {
5478
2
                                                    opcode: ref v22,
5479
2
                                                    imm: v23,
5480
                                                } => {
5481
2
                                                    if let &Opcode::Iconst = v22 {
5482
2
                                                        let v541 = C::fits_in_64(ctx, v2.0);
5483
2
                                                        if let Some(v542) = v541 {
5484
2
                                                            if v19.0 == v542 {
5485
2
                                                                let v574 = C::imm64_shl(ctx, v542, v23, v15);
5486
2
                                                                let v575 = constructor_iconst(ctx, v542, v574);
5487
2
                                                                let v576 = C::subsume(ctx, v575);
5488
                                                                // Rule at src/opts/cprop.isle line 55.
5489
2
                                                                returns.extend(Some(v576));
5490
2
                                                                if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
5491
0
                                                            }
5492
0
                                                        }
5493
0
                                                    }
5494
                                                }
5495
45.7k
                                                _ => {}
5496
                                            }
5497
                                        }
5498
58.4k
                                        let v16 = C::u64_from_imm64(ctx, v15);
5499
58.4k
                                        if v16 == 0x0_u64 {
5500
0
                                            if v2.0 == v11.0 {
5501
0
                                                let v17 = C::subsume(ctx, v7.0);
5502
                                                // Rule at src/opts/shifts.isle line 3.
5503
0
                                                returns.extend(Some(v17));
5504
0
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
5505
0
                                            }
5506
58.4k
                                        }
5507
58.4k
                                        let v250 = constructor_ty_shift_mask(ctx, v2.0);
5508
58.4k
                                        let v1260 = C::u64_and(ctx, v16, v250);
5509
58.4k
                                        let v1287 = C::u64_eq(ctx, v16, v1260);
5510
58.4k
                                        if v1287 == false {
5511
0
                                            let v1288 = constructor_iconst_u(ctx, v11.0, v1260);
5512
0
                                            let v1289 = constructor_ishl(ctx, v2.0, v7.0, v1288);
5513
                                            // Rule at src/opts/shifts.isle line 292.
5514
0
                                            returns.extend(Some(v1289));
5515
0
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
5516
58.4k
                                        }
5517
0
                                    }
5518
                                }
5519
31
                                _ => {}
5520
                            }
5521
                        }
5522
59.0k
                        let mut v18 = C::inst_data_value_etor_returns::default();
5523
59.0k
                        C::inst_data_value_etor(ctx, v7.0, &mut v18);
5524
59.0k
                        let mut v18 = v18.into_context_iter();
5525
115k
                        while let Some(
v1956.1k
) = v18.next(ctx) {
5526
                            if let &InstructionData::Unary {
5527
34.4k
                                opcode: ref v29,
5528
34.4k
                                arg: v30,
5529
56.1k
                            } = &v19.1 {
5530
34.4k
                                if let &Opcode::Splat = v29 {
5531
0
                                    if v2.0 == v19.0 {
5532
0
                                        let v1262 = C::lane_type(ctx, v2.0);
5533
0
                                        let v1418 = constructor_ishl(ctx, v1262, v30, v7.1);
5534
0
                                        let v1419 = constructor_splat(ctx, v2.0, v1418);
5535
                                        // Rule at src/opts/vector.isle line 74.
5536
0
                                        returns.extend(Some(v1419));
5537
0
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
5538
0
                                    }
5539
34.4k
                                }
5540
21.6k
                            }
5541
                        }
5542
                    }
5543
                    &Opcode::Ushr => {
5544
18.2k
                        let v7 = C::unpack_value_array_2(ctx, v6);
5545
18.2k
                        let mut v10 = C::inst_data_value_etor_returns::default();
5546
18.2k
                        C::inst_data_value_etor(ctx, v7.1, &mut v10);
5547
18.2k
                        let mut v10 = v10.into_context_iter();
5548
36.4k
                        while let Some(
v1118.2k
) = v10.next(ctx) {
5549
18.2k
                            match &v11.1 {
5550
                                &InstructionData::Binary {
5551
348
                                    opcode: ref v104,
5552
348
                                    args: ref v105,
5553
                                } => {
5554
348
                                    if let &Opcode::Iconcat = v104 {
5555
0
                                        let v106 = C::unpack_value_array_2(ctx, v105);
5556
0
                                        let v1255 = constructor_ushr(ctx, v2.0, v7.0, v106.0);
5557
                                        // Rule at src/opts/shifts.isle line 139.
5558
0
                                        returns.extend(Some(v1255));
5559
0
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
5560
348
                                    }
5561
                                }
5562
                                &InstructionData::Unary {
5563
152
                                    opcode: ref v26,
5564
152
                                    arg: v27,
5565
                                } => {
5566
152
                                    match v26 {
5567
                                        &Opcode::Ireduce => {
5568
0
                                            let v974 = C::value_type(ctx, v27);
5569
0
                                            let v1247 = C::fits_in_64(ctx, v974);
5570
0
                                            if let Some(v1248) = v1247 {
5571
0
                                                let v1250 = constructor_ushr(ctx, v2.0, v7.0, v27);
5572
                                                // Rule at src/opts/shifts.isle line 117.
5573
0
                                                returns.extend(Some(v1250));
5574
0
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
5575
0
                                            }
5576
                                        }
5577
                                        &Opcode::Uextend => {
5578
111
                                            let v1250 = constructor_ushr(ctx, v2.0, v7.0, v27);
5579
                                            // Rule at src/opts/shifts.isle line 118.
5580
111
                                            returns.extend(Some(v1250));
5581
111
                                            if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
5582
                                        }
5583
                                        &Opcode::Sextend => {
5584
0
                                            let v1250 = constructor_ushr(ctx, v2.0, v7.0, v27);
5585
                                            // Rule at src/opts/shifts.isle line 119.
5586
0
                                            returns.extend(Some(v1250));
5587
0
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
5588
                                        }
5589
41
                                        _ => {}
5590
                                    }
5591
                                }
5592
                                &InstructionData::UnaryImm {
5593
17.6k
                                    opcode: ref v14,
5594
17.6k
                                    imm: v15,
5595
                                } => {
5596
17.6k
                                    if let &Opcode::Iconst = v14 {
5597
17.6k
                                        let mut v18 = C::inst_data_value_etor_returns::default();
5598
17.6k
                                        C::inst_data_value_etor(ctx, v7.0, &mut v18);
5599
17.6k
                                        let mut v18 = v18.into_context_iter();
5600
32.7k
                                        while let Some(
v1915.0k
) = v18.next(ctx) {
5601
15.0k
                                            match &v19.1 {
5602
                                                &InstructionData::Binary {
5603
9.91k
                                                    opcode: ref v122,
5604
9.91k
                                                    args: ref v123,
5605
                                                } => {
5606
9.91k
                                                    match v122 {
5607
                                                        &Opcode::Imul => {
5608
1.51k
                                                            let v206 = C::ty_half_width(ctx, v2.0);
5609
1.51k
                                                            if let Some(v207) = v206 {
5610
1.51k
                                                                if v2.0 == v19.0 {
5611
1.51k
                                                                    let v124 = C::unpack_value_array_2(ctx, v123);
5612
1.51k
                                                                    let mut v127 = C::inst_data_value_etor_returns::default();
5613
1.51k
                                                                    C::inst_data_value_etor(ctx, v124.0, &mut v127);
5614
1.51k
                                                                    let mut v127 = v127.into_context_iter();
5615
3.02k
                                                                    while let Some(
v1281.50k
) = v127.next(ctx) {
5616
                                                                        if let &InstructionData::Unary {
5617
1.49k
                                                                            opcode: ref v196,
5618
1.49k
                                                                            arg: v197,
5619
1.50k
                                                                        } = &v128.1 {
5620
1.49k
                                                                            if let &Opcode::Uextend = v196 {
5621
1.49k
                                                                                let v198 = C::value_type(ctx, v197);
5622
1.49k
                                                                                let v208 = C::ty_equal(ctx, v198, v207);
5623
1.49k
                                                                                if v208 == true {
5624
1.49k
                                                                                    let v16 = C::u64_from_imm64(ctx, v15);
5625
1.49k
                                                                                    let v209 = C::ty_bits_u64(ctx, v198);
5626
1.49k
                                                                                    let v210 = C::u64_eq(ctx, v16, v209);
5627
1.49k
                                                                                    if v210 == true {
5628
1.49k
                                                                                        let mut v199 = C::inst_data_value_etor_returns::default();
5629
1.49k
                                                                                        C::inst_data_value_etor(ctx, v124.1, &mut v199);
5630
1.49k
                                                                                        let mut v199 = v199.into_context_iter();
5631
2.98k
                                                                                        while let Some(
v2001.49k
) = v199.next(ctx) {
5632
                                                                                            if let &InstructionData::Unary {
5633
0
                                                                                                opcode: ref v203,
5634
0
                                                                                                arg: v204,
5635
1.49k
                                                                                            } = &v200.1 {
5636
0
                                                                                                if let &Opcode::Uextend = v203 {
5637
0
                                                                                                    let v205 = C::value_type(ctx, v204);
5638
0
                                                                                                    if v198 == v205 {
5639
0
                                                                                                        let v213 = constructor_umulhi(ctx, v198, v197, v204);
5640
0
                                                                                                        let v214 = constructor_uextend(ctx, v2.0, v213);
5641
                                                                                                        // Rule at src/opts/arithmetic.isle line 302.
5642
0
                                                                                                        returns.extend(Some(v214));
5643
0
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
5644
0
                                                                                                    }
5645
0
                                                                                                }
5646
1.49k
                                                                                            }
5647
                                                                                        }
5648
0
                                                                                    }
5649
0
                                                                                }
5650
0
                                                                            }
5651
15
                                                                        }
5652
                                                                    }
5653
0
                                                                }
5654
0
                                                            }
5655
                                                        }
5656
                                                        &Opcode::Ishl => {
5657
702
                                                            let v124 = C::unpack_value_array_2(ctx, v123);
5658
702
                                                            let mut v199 = C::inst_data_value_etor_returns::default();
5659
702
                                                            C::inst_data_value_etor(ctx, v124.1, &mut v199);
5660
702
                                                            let mut v199 = v199.into_context_iter();
5661
1.40k
                                                            while let Some(
v200702
) = v199.next(ctx) {
5662
                                                                if let &InstructionData::UnaryImm {
5663
672
                                                                    opcode: ref v241,
5664
672
                                                                    imm: v242,
5665
702
                                                                } = &v200.1 {
5666
672
                                                                    if let &Opcode::Iconst = v241 {
5667
672
                                                                        if v15 == v242 {
5668
653
                                                                            let v52 = C::ty_int(ctx, v2.0);
5669
653
                                                                            if let Some(v53) = v52 {
5670
653
                                                                                let v243 = C::u64_from_imm64(ctx, v242);
5671
653
                                                                                let v1228 = C::u64_matches_non_zero(ctx, v243);
5672
653
                                                                                if let Some(v1229) = v1228 {
5673
653
                                                                                    if v1229 == true {
5674
653
                                                                                        let v1230 = C::ty_bits(ctx, v53);
5675
653
                                                                                        let v1231 = C::u8_into_u64(ctx, v1230);
5676
653
                                                                                        let v1232 = C::u64_wrapping_sub(ctx, v1231, v243);
5677
653
                                                                                        let v1233 = constructor_shift_amt_to_type(ctx, v1232);
5678
653
                                                                                        if let Some(
v12340
) = v1233 {
5679
0
                                                                                            if v19.0 == v53 {
5680
0
                                                                                                let v1235 = constructor_ireduce(ctx, v1234, v124.0);
5681
0
                                                                                                let v1237 = constructor_uextend(ctx, v53, v1235);
5682
                                                                                                // Rule at src/opts/shifts.isle line 87.
5683
0
                                                                                                returns.extend(Some(v1237));
5684
0
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
5685
0
                                                                                            }
5686
653
                                                                                        }
5687
0
                                                                                    }
5688
0
                                                                                }
5689
0
                                                                            }
5690
653
                                                                            let v541 = C::fits_in_64(ctx, v2.0);
5691
653
                                                                            if let Some(v542) = v541 {
5692
653
                                                                                let v1063 = C::ty_int(ctx, v542);
5693
653
                                                                                if let Some(v1064) = v1063 {
5694
653
                                                                                    if v19.0 == v1064 {
5695
653
                                                                                        let v1217 = C::ty_mask(ctx, v1064);
5696
653
                                                                                        let v1218 = C::imm64(ctx, v1217);
5697
653
                                                                                        let v1219 = C::imm64_ushr(ctx, v1064, v1218, v242);
5698
653
                                                                                        let v1220 = constructor_iconst(ctx, v1064, v1219);
5699
653
                                                                                        let v1221 = constructor_band(ctx, v1064, v124.0, v1220);
5700
                                                                                        // Rule at src/opts/shifts.isle line 40.
5701
653
                                                                                        returns.extend(Some(v1221));
5702
653
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
5703
0
                                                                                    }
5704
0
                                                                                }
5705
0
                                                                            }
5706
19
                                                                        }
5707
0
                                                                    }
5708
30
                                                                }
5709
                                                            }
5710
                                                        }
5711
                                                        &Opcode::Ushr => {
5712
11
                                                            if v2.0 == v19.0 {
5713
11
                                                                let v124 = C::unpack_value_array_2(ctx, v123);
5714
11
                                                                let mut v199 = C::inst_data_value_etor_returns::default();
5715
11
                                                                C::inst_data_value_etor(ctx, v124.1, &mut v199);
5716
11
                                                                let mut v199 = v199.into_context_iter();
5717
22
                                                                while let Some(
v20011
) = v199.next(ctx) {
5718
                                                                    if let &InstructionData::UnaryImm {
5719
11
                                                                        opcode: ref v241,
5720
11
                                                                        imm: v242,
5721
11
                                                                    } = &v200.1 {
5722
11
                                                                        if let &Opcode::Iconst = v241 {
5723
11
                                                                            let v243 = C::u64_from_imm64(ctx, v242);
5724
11
                                                                            let v250 = constructor_ty_shift_mask(ctx, v2.0);
5725
11
                                                                            let v1259 = C::u64_and(ctx, v243, v250);
5726
11
                                                                            let v16 = C::u64_from_imm64(ctx, v15);
5727
11
                                                                            let v1260 = C::u64_and(ctx, v16, v250);
5728
11
                                                                            let v1261 = C::u64_wrapping_add(ctx, v1259, v1260);
5729
11
                                                                            let v1262 = C::lane_type(ctx, v2.0);
5730
11
                                                                            let v1263 = C::ty_bits_u64(ctx, v1262);
5731
11
                                                                            let v1264 = C::u64_lt(ctx, v1261, v1263);
5732
11
                                                                            if v1264 == true {
5733
11
                                                                                let v1265 = constructor_iconst_u(ctx, v200.0, v1261);
5734
11
                                                                                let v1267 = constructor_ushr(ctx, v2.0, v124.0, v1265);
5735
                                                                                // Rule at src/opts/shifts.isle line 160.
5736
11
                                                                                returns.extend(Some(v1267));
5737
11
                                                                                if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
5738
0
                                                                            }
5739
11
                                                                            let v1222 = C::ty_bits_u64(ctx, v2.0);
5740
11
                                                                            let v1269 = C::u64_lt_eq(ctx, v1222, v1261);
5741
11
                                                                            if v1269 == true {
5742
0
                                                                                let v948 = constructor_iconst_u(ctx, v2.0, 0x0_u64);
5743
0
                                                                                let v949 = C::subsume(ctx, v948);
5744
                                                                                // Rule at src/opts/shifts.isle line 192.
5745
0
                                                                                returns.extend(Some(v949));
5746
0
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
5747
11
                                                                            }
5748
0
                                                                        }
5749
0
                                                                    }
5750
                                                                }
5751
11
                                                                let mut v127 = C::inst_data_value_etor_returns::default();
5752
11
                                                                C::inst_data_value_etor(ctx, v124.0, &mut v127);
5753
11
                                                                let mut v127 = v127.into_context_iter();
5754
21
                                                                while let Some(
v12810
) = v127.next(ctx) {
5755
                                                                    if let &InstructionData::UnaryImm {
5756
0
                                                                        opcode: ref v622,
5757
0
                                                                        imm: v623,
5758
10
                                                                    } = &v128.1 {
5759
0
                                                                        if let &Opcode::Iconst = v622 {
5760
0
                                                                            let v720 = constructor_ushr(ctx, v2.0, v124.0, v7.1);
5761
0
                                                                            let v721 = constructor_ushr(ctx, v2.0, v720, v124.1);
5762
                                                                            // Rule at src/opts/cprop.isle line 230.
5763
0
                                                                            returns.extend(Some(v721));
5764
0
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
5765
0
                                                                        }
5766
10
                                                                    }
5767
                                                                }
5768
0
                                                            }
5769
                                                        }
5770
7.68k
                                                        _ => {}
5771
                                                    }
5772
                                                }
5773
                                                &InstructionData::UnaryImm {
5774
0
                                                    opcode: ref v22,
5775
0
                                                    imm: v23,
5776
                                                } => {
5777
0
                                                    if let &Opcode::Iconst = v22 {
5778
0
                                                        let v541 = C::fits_in_64(ctx, v2.0);
5779
0
                                                        if let Some(v542) = v541 {
5780
0
                                                            if v19.0 == v542 {
5781
0
                                                                let v577 = C::imm64_ushr(ctx, v542, v23, v15);
5782
0
                                                                let v578 = constructor_iconst(ctx, v542, v577);
5783
0
                                                                let v579 = C::subsume(ctx, v578);
5784
                                                                // Rule at src/opts/cprop.isle line 60.
5785
0
                                                                returns.extend(Some(v579));
5786
0
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
5787
0
                                                            }
5788
0
                                                        }
5789
0
                                                    }
5790
                                                }
5791
5.13k
                                                _ => {}
5792
                                            }
5793
                                        }
5794
17.6k
                                        let v16 = C::u64_from_imm64(ctx, v15);
5795
17.6k
                                        if v16 == 0x0_u64 {
5796
0
                                            if v2.0 == v11.0 {
5797
0
                                                let v17 = C::subsume(ctx, v7.0);
5798
                                                // Rule at src/opts/shifts.isle line 7.
5799
0
                                                returns.extend(Some(v17));
5800
0
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
5801
0
                                            }
5802
17.6k
                                        }
5803
17.6k
                                        let v250 = constructor_ty_shift_mask(ctx, v2.0);
5804
17.6k
                                        let v1260 = C::u64_and(ctx, v16, v250);
5805
17.6k
                                        let v1287 = C::u64_eq(ctx, v16, v1260);
5806
17.6k
                                        if v1287 == false {
5807
0
                                            let v1288 = constructor_iconst_u(ctx, v11.0, v1260);
5808
0
                                            let v1290 = constructor_ushr(ctx, v2.0, v7.0, v1288);
5809
                                            // Rule at src/opts/shifts.isle line 295.
5810
0
                                            returns.extend(Some(v1290));
5811
0
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
5812
17.6k
                                        }
5813
0
                                    }
5814
                                }
5815
65
                                _ => {}
5816
                            }
5817
                        }
5818
18.2k
                        let mut v18 = C::inst_data_value_etor_returns::default();
5819
18.2k
                        C::inst_data_value_etor(ctx, v7.0, &mut v18);
5820
18.2k
                        let mut v18 = v18.into_context_iter();
5821
33.6k
                        while let Some(
v1915.3k
) = v18.next(ctx) {
5822
                            if let &InstructionData::Unary {
5823
533
                                opcode: ref v29,
5824
533
                                arg: v30,
5825
15.3k
                            } = &v19.1 {
5826
533
                                if let &Opcode::Splat = v29 {
5827
0
                                    if v2.0 == v19.0 {
5828
0
                                        let v1262 = C::lane_type(ctx, v2.0);
5829
0
                                        let v1420 = constructor_ushr(ctx, v1262, v30, v7.1);
5830
0
                                        let v1421 = constructor_splat(ctx, v2.0, v1420);
5831
                                        // Rule at src/opts/vector.isle line 77.
5832
0
                                        returns.extend(Some(v1421));
5833
0
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
5834
0
                                    }
5835
533
                                }
5836
14.8k
                            }
5837
                        }
5838
                    }
5839
                    &Opcode::Sshr => {
5840
911
                        let v7 = C::unpack_value_array_2(ctx, v6);
5841
911
                        let mut v10 = C::inst_data_value_etor_returns::default();
5842
911
                        C::inst_data_value_etor(ctx, v7.1, &mut v10);
5843
911
                        let mut v10 = v10.into_context_iter();
5844
1.82k
                        while let Some(
v11911
) = v10.next(ctx) {
5845
911
                            match &v11.1 {
5846
                                &InstructionData::Binary {
5847
0
                                    opcode: ref v104,
5848
0
                                    args: ref v105,
5849
                                } => {
5850
0
                                    if let &Opcode::Iconcat = v104 {
5851
0
                                        let v106 = C::unpack_value_array_2(ctx, v105);
5852
0
                                        let v1256 = constructor_sshr(ctx, v2.0, v7.0, v106.0);
5853
                                        // Rule at src/opts/shifts.isle line 140.
5854
0
                                        returns.extend(Some(v1256));
5855
0
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
5856
0
                                    }
5857
                                }
5858
                                &InstructionData::Unary {
5859
0
                                    opcode: ref v26,
5860
0
                                    arg: v27,
5861
                                } => {
5862
0
                                    match v26 {
5863
                                        &Opcode::Ireduce => {
5864
0
                                            let v974 = C::value_type(ctx, v27);
5865
0
                                            let v1247 = C::fits_in_64(ctx, v974);
5866
0
                                            if let Some(v1248) = v1247 {
5867
0
                                                let v1251 = constructor_sshr(ctx, v2.0, v7.0, v27);
5868
                                                // Rule at src/opts/shifts.isle line 120.
5869
0
                                                returns.extend(Some(v1251));
5870
0
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
5871
0
                                            }
5872
                                        }
5873
                                        &Opcode::Uextend => {
5874
0
                                            let v1251 = constructor_sshr(ctx, v2.0, v7.0, v27);
5875
                                            // Rule at src/opts/shifts.isle line 121.
5876
0
                                            returns.extend(Some(v1251));
5877
0
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
5878
                                        }
5879
                                        &Opcode::Sextend => {
5880
0
                                            let v1251 = constructor_sshr(ctx, v2.0, v7.0, v27);
5881
                                            // Rule at src/opts/shifts.isle line 122.
5882
0
                                            returns.extend(Some(v1251));
5883
0
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
5884
                                        }
5885
0
                                        _ => {}
5886
                                    }
5887
                                }
5888
                                &InstructionData::UnaryImm {
5889
911
                                    opcode: ref v14,
5890
911
                                    imm: v15,
5891
                                } => {
5892
911
                                    if let &Opcode::Iconst = v14 {
5893
911
                                        let mut v18 = C::inst_data_value_etor_returns::default();
5894
911
                                        C::inst_data_value_etor(ctx, v7.0, &mut v18);
5895
911
                                        let mut v18 = v18.into_context_iter();
5896
1.82k
                                        while let Some(
v19911
) = v18.next(ctx) {
5897
911
                                            match &v19.1 {
5898
                                                &InstructionData::Binary {
5899
911
                                                    opcode: ref v122,
5900
911
                                                    args: ref v123,
5901
                                                } => {
5902
911
                                                    match v122 {
5903
                                                        &Opcode::Imul => {
5904
0
                                                            let v206 = C::ty_half_width(ctx, v2.0);
5905
0
                                                            if let Some(v207) = v206 {
5906
0
                                                                if v2.0 == v19.0 {
5907
0
                                                                    let v124 = C::unpack_value_array_2(ctx, v123);
5908
0
                                                                    let mut v127 = C::inst_data_value_etor_returns::default();
5909
0
                                                                    C::inst_data_value_etor(ctx, v124.0, &mut v127);
5910
0
                                                                    let mut v127 = v127.into_context_iter();
5911
0
                                                                    while let Some(v128) = v127.next(ctx) {
5912
                                                                        if let &InstructionData::Unary {
5913
0
                                                                            opcode: ref v196,
5914
0
                                                                            arg: v197,
5915
0
                                                                        } = &v128.1 {
5916
0
                                                                            if let &Opcode::Sextend = v196 {
5917
0
                                                                                let v198 = C::value_type(ctx, v197);
5918
0
                                                                                let v208 = C::ty_equal(ctx, v198, v207);
5919
0
                                                                                if v208 == true {
5920
0
                                                                                    let v16 = C::u64_from_imm64(ctx, v15);
5921
0
                                                                                    let v209 = C::ty_bits_u64(ctx, v198);
5922
0
                                                                                    let v210 = C::u64_eq(ctx, v16, v209);
5923
0
                                                                                    if v210 == true {
5924
0
                                                                                        let mut v199 = C::inst_data_value_etor_returns::default();
5925
0
                                                                                        C::inst_data_value_etor(ctx, v124.1, &mut v199);
5926
0
                                                                                        let mut v199 = v199.into_context_iter();
5927
0
                                                                                        while let Some(v200) = v199.next(ctx) {
5928
                                                                                            if let &InstructionData::Unary {
5929
0
                                                                                                opcode: ref v203,
5930
0
                                                                                                arg: v204,
5931
0
                                                                                            } = &v200.1 {
5932
0
                                                                                                if let &Opcode::Sextend = v203 {
5933
0
                                                                                                    let v205 = C::value_type(ctx, v204);
5934
0
                                                                                                    if v198 == v205 {
5935
0
                                                                                                        let v211 = constructor_smulhi(ctx, v198, v197, v204);
5936
0
                                                                                                        let v212 = constructor_sextend(ctx, v2.0, v211);
5937
                                                                                                        // Rule at src/opts/arithmetic.isle line 296.
5938
0
                                                                                                        returns.extend(Some(v212));
5939
0
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
5940
0
                                                                                                    }
5941
0
                                                                                                }
5942
0
                                                                                            }
5943
                                                                                        }
5944
0
                                                                                    }
5945
0
                                                                                }
5946
0
                                                                            }
5947
0
                                                                        }
5948
                                                                    }
5949
0
                                                                }
5950
0
                                                            }
5951
                                                        }
5952
                                                        &Opcode::Bor => {
5953
0
                                                            let v16 = C::u64_from_imm64(ctx, v15);
5954
0
                                                            let v250 = constructor_ty_shift_mask(ctx, v2.0);
5955
0
                                                            let v251 = C::u64_eq(ctx, v16, v250);
5956
0
                                                            if v251 == true {
5957
0
                                                                if v2.0 == v11.0 {
5958
0
                                                                    if v2.0 == v19.0 {
5959
0
                                                                        let v124 = C::unpack_value_array_2(ctx, v123);
5960
0
                                                                        let mut v127 = C::inst_data_value_etor_returns::default();
5961
0
                                                                        C::inst_data_value_etor(ctx, v124.0, &mut v127);
5962
0
                                                                        let mut v127 = v127.into_context_iter();
5963
0
                                                                        while let Some(v128) = v127.next(ctx) {
5964
                                                                            if let &InstructionData::Unary {
5965
0
                                                                                opcode: ref v196,
5966
0
                                                                                arg: v197,
5967
0
                                                                            } = &v128.1 {
5968
0
                                                                                if let &Opcode::Ineg = v196 {
5969
0
                                                                                    if v2.0 == v128.0 {
5970
0
                                                                                        if v124.1 == v197 {
5971
0
                                                                                            let v253 = constructor_bmask(ctx, v2.0, v197);
5972
                                                                                            // Rule at src/opts/bitops.isle line 91.
5973
0
                                                                                            returns.extend(Some(v253));
5974
0
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
5975
0
                                                                                        }
5976
0
                                                                                    }
5977
0
                                                                                }
5978
0
                                                                            }
5979
                                                                        }
5980
0
                                                                        let mut v199 = C::inst_data_value_etor_returns::default();
5981
0
                                                                        C::inst_data_value_etor(ctx, v124.1, &mut v199);
5982
0
                                                                        let mut v199 = v199.into_context_iter();
5983
0
                                                                        while let Some(v200) = v199.next(ctx) {
5984
                                                                            if let &InstructionData::Unary {
5985
0
                                                                                opcode: ref v203,
5986
0
                                                                                arg: v204,
5987
0
                                                                            } = &v200.1 {
5988
0
                                                                                if let &Opcode::Ineg = v203 {
5989
0
                                                                                    if v124.0 == v204 {
5990
0
                                                                                        if v2.0 == v200.0 {
5991
0
                                                                                            let v252 = constructor_bmask(ctx, v2.0, v124.0);
5992
                                                                                            // Rule at src/opts/bitops.isle line 87.
5993
0
                                                                                            returns.extend(Some(v252));
5994
0
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
5995
0
                                                                                        }
5996
0
                                                                                    }
5997
0
                                                                                }
5998
0
                                                                            }
5999
                                                                        }
6000
0
                                                                    }
6001
0
                                                                }
6002
0
                                                            }
6003
                                                        }
6004
                                                        &Opcode::Ishl => {
6005
180
                                                            let v124 = C::unpack_value_array_2(ctx, v123);
6006
180
                                                            let mut v199 = C::inst_data_value_etor_returns::default();
6007
180
                                                            C::inst_data_value_etor(ctx, v124.1, &mut v199);
6008
180
                                                            let mut v199 = v199.into_context_iter();
6009
360
                                                            while let Some(
v200180
) = v199.next(ctx) {
6010
                                                                if let &InstructionData::UnaryImm {
6011
180
                                                                    opcode: ref v241,
6012
180
                                                                    imm: v242,
6013
180
                                                                } = &v200.1 {
6014
180
                                                                    if let &Opcode::Iconst = v241 {
6015
180
                                                                        if v2.0 == v19.0 {
6016
180
                                                                            let v16 = C::u64_from_imm64(ctx, v15);
6017
180
                                                                            let v243 = C::u64_from_imm64(ctx, v242);
6018
180
                                                                            if v16 == v243 {
6019
179
                                                                                let mut v127 = C::inst_data_value_etor_returns::default();
6020
179
                                                                                C::inst_data_value_etor(ctx, v124.0, &mut v127);
6021
179
                                                                                let mut v127 = v127.into_context_iter();
6022
304
                                                                                while let Some(
v128125
) = v127.next(ctx) {
6023
                                                                                    if let &InstructionData::Unary {
6024
40
                                                                                        opcode: ref v196,
6025
40
                                                                                        arg: v197,
6026
125
                                                                                    } = &v128.1 {
6027
40
                                                                                        match v196 {
6028
                                                                                            &Opcode::Uextend => {
6029
0
                                                                                                if v2.0 == v128.0 {
6030
0
                                                                                                    let v1222 = C::ty_bits_u64(ctx, v2.0);
6031
0
                                                                                                    let v198 = C::value_type(ctx, v197);
6032
0
                                                                                                    let v209 = C::ty_bits_u64(ctx, v198);
6033
0
                                                                                                    let v1223 = C::u64_wrapping_sub(ctx, v1222, v209);
6034
0
                                                                                                    let v1224 = C::u64_eq(ctx, v243, v1223);
6035
0
                                                                                                    if v1224 == true {
6036
0
                                                                                                        let v1225 = constructor_sextend(ctx, v2.0, v197);
6037
                                                                                                        // Rule at src/opts/shifts.isle line 49.
6038
0
                                                                                                        returns.extend(Some(v1225));
6039
0
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
6040
0
                                                                                                    }
6041
0
                                                                                                    let v1226 = C::u64_lt(ctx, v243, v1223);
6042
0
                                                                                                    if v1226 == true {
6043
                                                                                                        // Rule at src/opts/shifts.isle line 60.
6044
0
                                                                                                        returns.extend(Some(v124.0));
6045
0
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
6046
0
                                                                                                    }
6047
0
                                                                                                }
6048
                                                                                            }
6049
                                                                                            &Opcode::Sextend => {
6050
0
                                                                                                let v1222 = C::ty_bits_u64(ctx, v2.0);
6051
0
                                                                                                let v198 = C::value_type(ctx, v197);
6052
0
                                                                                                let v209 = C::ty_bits_u64(ctx, v198);
6053
0
                                                                                                let v1223 = C::u64_wrapping_sub(ctx, v1222, v209);
6054
0
                                                                                                let v1227 = C::u64_lt_eq(ctx, v243, v1223);
6055
0
                                                                                                if v1227 == true {
6056
0
                                                                                                    if v2.0 == v128.0 {
6057
                                                                                                        // Rule at src/opts/shifts.isle line 70.
6058
0
                                                                                                        returns.extend(Some(v124.0));
6059
0
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
6060
0
                                                                                                    }
6061
0
                                                                                                }
6062
                                                                                            }
6063
40
                                                                                            _ => {}
6064
                                                                                        }
6065
85
                                                                                    }
6066
                                                                                }
6067
1
                                                                            }
6068
0
                                                                        }
6069
180
                                                                        if v15 == v242 {
6070
179
                                                                            let v52 = C::ty_int(ctx, v2.0);
6071
179
                                                                            if let Some(v53) = v52 {
6072
179
                                                                                if v19.0 == v53 {
6073
179
                                                                                    let v243 = C::u64_from_imm64(ctx, v242);
6074
179
                                                                                    let v1228 = C::u64_matches_non_zero(ctx, v243);
6075
179
                                                                                    if let Some(v1229) = v1228 {
6076
179
                                                                                        if v1229 == true {
6077
179
                                                                                            let v1230 = C::ty_bits(ctx, v53);
6078
179
                                                                                            let v1231 = C::u8_into_u64(ctx, v1230);
6079
179
                                                                                            let v1232 = C::u64_wrapping_sub(ctx, v1231, v243);
6080
179
                                                                                            let v1233 = constructor_shift_amt_to_type(ctx, v1232);
6081
179
                                                                                            if let Some(
v1234131
) = v1233 {
6082
131
                                                                                                let v1235 = constructor_ireduce(ctx, v1234, v124.0);
6083
131
                                                                                                let v1236 = constructor_sextend(ctx, v53, v1235);
6084
                                                                                                // Rule at src/opts/shifts.isle line 83.
6085
131
                                                                                                returns.extend(Some(v1236));
6086
131
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
6087
48
                                                                                            }
6088
0
                                                                                        }
6089
0
                                                                                    }
6090
0
                                                                                }
6091
0
                                                                            }
6092
1
                                                                        }
6093
0
                                                                    }
6094
0
                                                                }
6095
                                                            }
6096
                                                        }
6097
                                                        &Opcode::Sshr => {
6098
0
                                                            if v2.0 == v19.0 {
6099
0
                                                                let v124 = C::unpack_value_array_2(ctx, v123);
6100
0
                                                                let mut v127 = C::inst_data_value_etor_returns::default();
6101
0
                                                                C::inst_data_value_etor(ctx, v124.0, &mut v127);
6102
0
                                                                let mut v127 = v127.into_context_iter();
6103
0
                                                                while let Some(v128) = v127.next(ctx) {
6104
                                                                    if let &InstructionData::UnaryImm {
6105
0
                                                                        opcode: ref v622,
6106
0
                                                                        imm: v623,
6107
0
                                                                    } = &v128.1 {
6108
0
                                                                        if let &Opcode::Iconst = v622 {
6109
0
                                                                            let v722 = constructor_sshr(ctx, v2.0, v124.0, v7.1);
6110
0
                                                                            let v723 = constructor_sshr(ctx, v2.0, v722, v124.1);
6111
                                                                            // Rule at src/opts/cprop.isle line 232.
6112
0
                                                                            returns.extend(Some(v723));
6113
0
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
6114
0
                                                                        }
6115
0
                                                                    }
6116
                                                                }
6117
0
                                                                let mut v199 = C::inst_data_value_etor_returns::default();
6118
0
                                                                C::inst_data_value_etor(ctx, v124.1, &mut v199);
6119
0
                                                                let mut v199 = v199.into_context_iter();
6120
0
                                                                while let Some(v200) = v199.next(ctx) {
6121
                                                                    if let &InstructionData::UnaryImm {
6122
0
                                                                        opcode: ref v241,
6123
0
                                                                        imm: v242,
6124
0
                                                                    } = &v200.1 {
6125
0
                                                                        if let &Opcode::Iconst = v241 {
6126
0
                                                                            let v243 = C::u64_from_imm64(ctx, v242);
6127
0
                                                                            let v250 = constructor_ty_shift_mask(ctx, v2.0);
6128
0
                                                                            let v1259 = C::u64_and(ctx, v243, v250);
6129
0
                                                                            let v16 = C::u64_from_imm64(ctx, v15);
6130
0
                                                                            let v1260 = C::u64_and(ctx, v16, v250);
6131
0
                                                                            let v1261 = C::u64_wrapping_add(ctx, v1259, v1260);
6132
0
                                                                            let v1262 = C::lane_type(ctx, v2.0);
6133
0
                                                                            let v1263 = C::ty_bits_u64(ctx, v1262);
6134
0
                                                                            let v1264 = C::u64_lt(ctx, v1261, v1263);
6135
0
                                                                            if v1264 == true {
6136
0
                                                                                let v1265 = constructor_iconst_u(ctx, v200.0, v1261);
6137
0
                                                                                let v1268 = constructor_sshr(ctx, v2.0, v124.0, v1265);
6138
                                                                                // Rule at src/opts/shifts.isle line 169.
6139
0
                                                                                returns.extend(Some(v1268));
6140
0
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
6141
0
                                                                            }
6142
0
                                                                        }
6143
0
                                                                    }
6144
                                                                }
6145
0
                                                            }
6146
                                                        }
6147
731
                                                        _ => {}
6148
                                                    }
6149
                                                }
6150
                                                &InstructionData::UnaryImm {
6151
0
                                                    opcode: ref v22,
6152
0
                                                    imm: v23,
6153
                                                } => {
6154
0
                                                    if let &Opcode::Iconst = v22 {
6155
0
                                                        let v541 = C::fits_in_64(ctx, v2.0);
6156
0
                                                        if let Some(v542) = v541 {
6157
0
                                                            if v19.0 == v542 {
6158
0
                                                                let v580 = C::imm64_sshr(ctx, v542, v23, v15);
6159
0
                                                                let v581 = constructor_iconst(ctx, v542, v580);
6160
0
                                                                let v582 = C::subsume(ctx, v581);
6161
                                                                // Rule at src/opts/cprop.isle line 65.
6162
0
                                                                returns.extend(Some(v582));
6163
0
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
6164
0
                                                            }
6165
0
                                                        }
6166
0
                                                    }
6167
                                                }
6168
0
                                                _ => {}
6169
                                            }
6170
                                        }
6171
911
                                        let v16 = C::u64_from_imm64(ctx, v15);
6172
911
                                        if v16 == 0x0_u64 {
6173
0
                                            if v2.0 == v11.0 {
6174
0
                                                let v17 = C::subsume(ctx, v7.0);
6175
                                                // Rule at src/opts/shifts.isle line 11.
6176
0
                                                returns.extend(Some(v17));
6177
0
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
6178
0
                                            }
6179
911
                                        }
6180
911
                                        let v250 = constructor_ty_shift_mask(ctx, v2.0);
6181
911
                                        let v1260 = C::u64_and(ctx, v16, v250);
6182
911
                                        let v1287 = C::u64_eq(ctx, v16, v1260);
6183
911
                                        if v1287 == false {
6184
0
                                            let v1288 = constructor_iconst_u(ctx, v11.0, v1260);
6185
0
                                            let v1291 = constructor_sshr(ctx, v2.0, v7.0, v1288);
6186
                                            // Rule at src/opts/shifts.isle line 298.
6187
0
                                            returns.extend(Some(v1291));
6188
0
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
6189
911
                                        }
6190
0
                                    }
6191
                                }
6192
0
                                _ => {}
6193
                            }
6194
                        }
6195
911
                        let mut v18 = C::inst_data_value_etor_returns::default();
6196
911
                        C::inst_data_value_etor(ctx, v7.0, &mut v18);
6197
911
                        let mut v18 = v18.into_context_iter();
6198
1.82k
                        while let Some(
v19911
) = v18.next(ctx) {
6199
                            if let &InstructionData::Unary {
6200
0
                                opcode: ref v29,
6201
0
                                arg: v30,
6202
911
                            } = &v19.1 {
6203
0
                                if let &Opcode::Splat = v29 {
6204
0
                                    if v2.0 == v19.0 {
6205
0
                                        let v1262 = C::lane_type(ctx, v2.0);
6206
0
                                        let v1422 = constructor_sshr(ctx, v1262, v30, v7.1);
6207
0
                                        let v1423 = constructor_splat(ctx, v2.0, v1422);
6208
                                        // Rule at src/opts/vector.isle line 80.
6209
0
                                        returns.extend(Some(v1423));
6210
0
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
6211
0
                                    }
6212
0
                                }
6213
911
                            }
6214
                        }
6215
                    }
6216
                    &Opcode::Fadd => {
6217
0
                        match v2.0 {
6218
                            F32 => {
6219
0
                                let v7 = C::unpack_value_array_2(ctx, v6);
6220
0
                                let mut v10 = C::inst_data_value_etor_returns::default();
6221
0
                                C::inst_data_value_etor(ctx, v7.1, &mut v10);
6222
0
                                let mut v10 = v10.into_context_iter();
6223
0
                                while let Some(v11) = v10.next(ctx) {
6224
0
                                    if v11.0 == F32 {
6225
                                        if let &InstructionData::UnaryIeee32 {
6226
0
                                            opcode: ref v765,
6227
0
                                            imm: v766,
6228
0
                                        } = &v11.1 {
6229
0
                                            if let &Opcode::F32const = v765 {
6230
0
                                                let mut v18 = C::inst_data_value_etor_returns::default();
6231
0
                                                C::inst_data_value_etor(ctx, v7.0, &mut v18);
6232
0
                                                let mut v18 = v18.into_context_iter();
6233
0
                                                while let Some(v19) = v18.next(ctx) {
6234
0
                                                    if v19.0 == F32 {
6235
                                                        if let &InstructionData::UnaryIeee32 {
6236
0
                                                            opcode: ref v763,
6237
0
                                                            imm: v764,
6238
0
                                                        } = &v19.1 {
6239
0
                                                            if let &Opcode::F32const = v763 {
6240
0
                                                                let v767 = C::f32_add(ctx, v764, v766);
6241
0
                                                                if let Some(v768) = v767 {
6242
0
                                                                    let v769 = constructor_f32const(ctx, F32, v768);
6243
0
                                                                    let v770 = C::subsume(ctx, v769);
6244
                                                                    // Rule at src/opts/cprop.isle line 306.
6245
0
                                                                    returns.extend(Some(v770));
6246
0
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
6247
0
                                                                }
6248
0
                                                            }
6249
0
                                                        }
6250
0
                                                    }
6251
                                                }
6252
0
                                            }
6253
0
                                        }
6254
0
                                    }
6255
                                }
6256
                            }
6257
                            F64 => {
6258
0
                                let v7 = C::unpack_value_array_2(ctx, v6);
6259
0
                                let mut v10 = C::inst_data_value_etor_returns::default();
6260
0
                                C::inst_data_value_etor(ctx, v7.1, &mut v10);
6261
0
                                let mut v10 = v10.into_context_iter();
6262
0
                                while let Some(v11) = v10.next(ctx) {
6263
0
                                    if v11.0 == F64 {
6264
                                        if let &InstructionData::UnaryIeee64 {
6265
0
                                            opcode: ref v773,
6266
0
                                            imm: v774,
6267
0
                                        } = &v11.1 {
6268
0
                                            if let &Opcode::F64const = v773 {
6269
0
                                                let mut v18 = C::inst_data_value_etor_returns::default();
6270
0
                                                C::inst_data_value_etor(ctx, v7.0, &mut v18);
6271
0
                                                let mut v18 = v18.into_context_iter();
6272
0
                                                while let Some(v19) = v18.next(ctx) {
6273
0
                                                    if v19.0 == F64 {
6274
                                                        if let &InstructionData::UnaryIeee64 {
6275
0
                                                            opcode: ref v771,
6276
0
                                                            imm: v772,
6277
0
                                                        } = &v19.1 {
6278
0
                                                            if let &Opcode::F64const = v771 {
6279
0
                                                                let v775 = C::f64_add(ctx, v772, v774);
6280
0
                                                                if let Some(v776) = v775 {
6281
0
                                                                    let v777 = constructor_f64const(ctx, F64, v776);
6282
0
                                                                    let v778 = C::subsume(ctx, v777);
6283
                                                                    // Rule at src/opts/cprop.isle line 309.
6284
0
                                                                    returns.extend(Some(v778));
6285
0
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
6286
0
                                                                }
6287
0
                                                            }
6288
0
                                                        }
6289
0
                                                    }
6290
                                                }
6291
0
                                            }
6292
0
                                        }
6293
0
                                    }
6294
                                }
6295
                            }
6296
0
                            _ => {}
6297
                        }
6298
                    }
6299
                    &Opcode::Fsub => {
6300
0
                        match v2.0 {
6301
                            F32 => {
6302
0
                                let v7 = C::unpack_value_array_2(ctx, v6);
6303
0
                                let mut v10 = C::inst_data_value_etor_returns::default();
6304
0
                                C::inst_data_value_etor(ctx, v7.1, &mut v10);
6305
0
                                let mut v10 = v10.into_context_iter();
6306
0
                                while let Some(v11) = v10.next(ctx) {
6307
0
                                    if v11.0 == F32 {
6308
                                        if let &InstructionData::UnaryIeee32 {
6309
0
                                            opcode: ref v765,
6310
0
                                            imm: v766,
6311
0
                                        } = &v11.1 {
6312
0
                                            if let &Opcode::F32const = v765 {
6313
0
                                                let mut v18 = C::inst_data_value_etor_returns::default();
6314
0
                                                C::inst_data_value_etor(ctx, v7.0, &mut v18);
6315
0
                                                let mut v18 = v18.into_context_iter();
6316
0
                                                while let Some(v19) = v18.next(ctx) {
6317
0
                                                    if v19.0 == F32 {
6318
                                                        if let &InstructionData::UnaryIeee32 {
6319
0
                                                            opcode: ref v763,
6320
0
                                                            imm: v764,
6321
0
                                                        } = &v19.1 {
6322
0
                                                            if let &Opcode::F32const = v763 {
6323
0
                                                                let v779 = C::f32_sub(ctx, v764, v766);
6324
0
                                                                if let Some(v780) = v779 {
6325
0
                                                                    let v781 = constructor_f32const(ctx, F32, v780);
6326
0
                                                                    let v782 = C::subsume(ctx, v781);
6327
                                                                    // Rule at src/opts/cprop.isle line 313.
6328
0
                                                                    returns.extend(Some(v782));
6329
0
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
6330
0
                                                                }
6331
0
                                                            }
6332
0
                                                        }
6333
0
                                                    }
6334
                                                }
6335
0
                                            }
6336
0
                                        }
6337
0
                                    }
6338
                                }
6339
                            }
6340
                            F64 => {
6341
0
                                let v7 = C::unpack_value_array_2(ctx, v6);
6342
0
                                let mut v10 = C::inst_data_value_etor_returns::default();
6343
0
                                C::inst_data_value_etor(ctx, v7.1, &mut v10);
6344
0
                                let mut v10 = v10.into_context_iter();
6345
0
                                while let Some(v11) = v10.next(ctx) {
6346
0
                                    if v11.0 == F64 {
6347
                                        if let &InstructionData::UnaryIeee64 {
6348
0
                                            opcode: ref v773,
6349
0
                                            imm: v774,
6350
0
                                        } = &v11.1 {
6351
0
                                            if let &Opcode::F64const = v773 {
6352
0
                                                let mut v18 = C::inst_data_value_etor_returns::default();
6353
0
                                                C::inst_data_value_etor(ctx, v7.0, &mut v18);
6354
0
                                                let mut v18 = v18.into_context_iter();
6355
0
                                                while let Some(v19) = v18.next(ctx) {
6356
0
                                                    if v19.0 == F64 {
6357
                                                        if let &InstructionData::UnaryIeee64 {
6358
0
                                                            opcode: ref v771,
6359
0
                                                            imm: v772,
6360
0
                                                        } = &v19.1 {
6361
0
                                                            if let &Opcode::F64const = v771 {
6362
0
                                                                let v783 = C::f64_sub(ctx, v772, v774);
6363
0
                                                                if let Some(v784) = v783 {
6364
0
                                                                    let v785 = constructor_f64const(ctx, F64, v784);
6365
0
                                                                    let v786 = C::subsume(ctx, v785);
6366
                                                                    // Rule at src/opts/cprop.isle line 316.
6367
0
                                                                    returns.extend(Some(v786));
6368
0
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
6369
0
                                                                }
6370
0
                                                            }
6371
0
                                                        }
6372
0
                                                    }
6373
                                                }
6374
0
                                            }
6375
0
                                        }
6376
0
                                    }
6377
                                }
6378
                            }
6379
0
                            _ => {}
6380
                        }
6381
                    }
6382
                    &Opcode::Fmul => {
6383
0
                        let v7 = C::unpack_value_array_2(ctx, v6);
6384
0
                        let mut v10 = C::inst_data_value_etor_returns::default();
6385
0
                        C::inst_data_value_etor(ctx, v7.1, &mut v10);
6386
0
                        let mut v10 = v10.into_context_iter();
6387
0
                        while let Some(v11) = v10.next(ctx) {
6388
0
                            match &v11.1 {
6389
                                &InstructionData::Unary {
6390
0
                                    opcode: ref v26,
6391
0
                                    arg: v27,
6392
                                } => {
6393
0
                                    if let &Opcode::Fneg = v26 {
6394
0
                                        if v2.0 == v11.0 {
6395
0
                                            let mut v18 = C::inst_data_value_etor_returns::default();
6396
0
                                            C::inst_data_value_etor(ctx, v7.0, &mut v18);
6397
0
                                            let mut v18 = v18.into_context_iter();
6398
0
                                            while let Some(v19) = v18.next(ctx) {
6399
                                                if let &InstructionData::Unary {
6400
0
                                                    opcode: ref v29,
6401
0
                                                    arg: v30,
6402
0
                                                } = &v19.1 {
6403
0
                                                    if let &Opcode::Fneg = v29 {
6404
0
                                                        if v2.0 == v19.0 {
6405
0
                                                            let v103 = constructor_fmul(ctx, v2.0, v30, v27);
6406
                                                            // Rule at src/opts/arithmetic.isle line 191.
6407
0
                                                            returns.extend(Some(v103));
6408
0
                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
6409
0
                                                        }
6410
0
                                                    }
6411
0
                                                }
6412
                                            }
6413
0
                                        }
6414
0
                                    }
6415
                                }
6416
                                &InstructionData::UnaryIeee32 {
6417
0
                                    opcode: ref v765,
6418
0
                                    imm: v766,
6419
                                } => {
6420
0
                                    if let &Opcode::F32const = v765 {
6421
0
                                        if v2.0 == F32 {
6422
0
                                            if v11.0 == F32 {
6423
0
                                                let mut v18 = C::inst_data_value_etor_returns::default();
6424
0
                                                C::inst_data_value_etor(ctx, v7.0, &mut v18);
6425
0
                                                let mut v18 = v18.into_context_iter();
6426
0
                                                while let Some(v19) = v18.next(ctx) {
6427
0
                                                    if v19.0 == F32 {
6428
                                                        if let &InstructionData::UnaryIeee32 {
6429
0
                                                            opcode: ref v763,
6430
0
                                                            imm: v764,
6431
0
                                                        } = &v19.1 {
6432
0
                                                            if let &Opcode::F32const = v763 {
6433
0
                                                                let v787 = C::f32_mul(ctx, v764, v766);
6434
0
                                                                if let Some(v788) = v787 {
6435
0
                                                                    let v789 = constructor_f32const(ctx, F32, v788);
6436
0
                                                                    let v790 = C::subsume(ctx, v789);
6437
                                                                    // Rule at src/opts/cprop.isle line 320.
6438
0
                                                                    returns.extend(Some(v790));
6439
0
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
6440
0
                                                                }
6441
0
                                                            }
6442
0
                                                        }
6443
0
                                                    }
6444
                                                }
6445
0
                                            }
6446
0
                                        }
6447
0
                                    }
6448
                                }
6449
                                &InstructionData::UnaryIeee64 {
6450
0
                                    opcode: ref v773,
6451
0
                                    imm: v774,
6452
                                } => {
6453
0
                                    if let &Opcode::F64const = v773 {
6454
0
                                        if v2.0 == F64 {
6455
0
                                            if v11.0 == F64 {
6456
0
                                                let mut v18 = C::inst_data_value_etor_returns::default();
6457
0
                                                C::inst_data_value_etor(ctx, v7.0, &mut v18);
6458
0
                                                let mut v18 = v18.into_context_iter();
6459
0
                                                while let Some(v19) = v18.next(ctx) {
6460
0
                                                    if v19.0 == F64 {
6461
                                                        if let &InstructionData::UnaryIeee64 {
6462
0
                                                            opcode: ref v771,
6463
0
                                                            imm: v772,
6464
0
                                                        } = &v19.1 {
6465
0
                                                            if let &Opcode::F64const = v771 {
6466
0
                                                                let v791 = C::f64_mul(ctx, v772, v774);
6467
0
                                                                if let Some(v792) = v791 {
6468
0
                                                                    let v793 = constructor_f64const(ctx, F64, v792);
6469
0
                                                                    let v794 = C::subsume(ctx, v793);
6470
                                                                    // Rule at src/opts/cprop.isle line 323.
6471
0
                                                                    returns.extend(Some(v794));
6472
0
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
6473
0
                                                                }
6474
0
                                                            }
6475
0
                                                        }
6476
0
                                                    }
6477
                                                }
6478
0
                                            }
6479
0
                                        }
6480
0
                                    }
6481
                                }
6482
0
                                _ => {}
6483
                            }
6484
                        }
6485
                    }
6486
                    &Opcode::Fdiv => {
6487
0
                        match v2.0 {
6488
                            F32 => {
6489
0
                                let v7 = C::unpack_value_array_2(ctx, v6);
6490
0
                                let mut v10 = C::inst_data_value_etor_returns::default();
6491
0
                                C::inst_data_value_etor(ctx, v7.1, &mut v10);
6492
0
                                let mut v10 = v10.into_context_iter();
6493
0
                                while let Some(v11) = v10.next(ctx) {
6494
0
                                    if v11.0 == F32 {
6495
                                        if let &InstructionData::UnaryIeee32 {
6496
0
                                            opcode: ref v765,
6497
0
                                            imm: v766,
6498
0
                                        } = &v11.1 {
6499
0
                                            if let &Opcode::F32const = v765 {
6500
0
                                                let mut v18 = C::inst_data_value_etor_returns::default();
6501
0
                                                C::inst_data_value_etor(ctx, v7.0, &mut v18);
6502
0
                                                let mut v18 = v18.into_context_iter();
6503
0
                                                while let Some(v19) = v18.next(ctx) {
6504
0
                                                    if v19.0 == F32 {
6505
                                                        if let &InstructionData::UnaryIeee32 {
6506
0
                                                            opcode: ref v763,
6507
0
                                                            imm: v764,
6508
0
                                                        } = &v19.1 {
6509
0
                                                            if let &Opcode::F32const = v763 {
6510
0
                                                                let v795 = C::f32_div(ctx, v764, v766);
6511
0
                                                                if let Some(v796) = v795 {
6512
0
                                                                    let v797 = constructor_f32const(ctx, F32, v796);
6513
0
                                                                    let v798 = C::subsume(ctx, v797);
6514
                                                                    // Rule at src/opts/cprop.isle line 327.
6515
0
                                                                    returns.extend(Some(v798));
6516
0
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
6517
0
                                                                }
6518
0
                                                            }
6519
0
                                                        }
6520
0
                                                    }
6521
                                                }
6522
0
                                            }
6523
0
                                        }
6524
0
                                    }
6525
                                }
6526
                            }
6527
                            F64 => {
6528
0
                                let v7 = C::unpack_value_array_2(ctx, v6);
6529
0
                                let mut v10 = C::inst_data_value_etor_returns::default();
6530
0
                                C::inst_data_value_etor(ctx, v7.1, &mut v10);
6531
0
                                let mut v10 = v10.into_context_iter();
6532
0
                                while let Some(v11) = v10.next(ctx) {
6533
0
                                    if v11.0 == F64 {
6534
                                        if let &InstructionData::UnaryIeee64 {
6535
0
                                            opcode: ref v773,
6536
0
                                            imm: v774,
6537
0
                                        } = &v11.1 {
6538
0
                                            if let &Opcode::F64const = v773 {
6539
0
                                                let mut v18 = C::inst_data_value_etor_returns::default();
6540
0
                                                C::inst_data_value_etor(ctx, v7.0, &mut v18);
6541
0
                                                let mut v18 = v18.into_context_iter();
6542
0
                                                while let Some(v19) = v18.next(ctx) {
6543
0
                                                    if v19.0 == F64 {
6544
                                                        if let &InstructionData::UnaryIeee64 {
6545
0
                                                            opcode: ref v771,
6546
0
                                                            imm: v772,
6547
0
                                                        } = &v19.1 {
6548
0
                                                            if let &Opcode::F64const = v771 {
6549
0
                                                                let v799 = C::f64_div(ctx, v772, v774);
6550
0
                                                                if let Some(v800) = v799 {
6551
0
                                                                    let v801 = constructor_f64const(ctx, F64, v800);
6552
0
                                                                    let v802 = C::subsume(ctx, v801);
6553
                                                                    // Rule at src/opts/cprop.isle line 330.
6554
0
                                                                    returns.extend(Some(v802));
6555
0
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
6556
0
                                                                }
6557
0
                                                            }
6558
0
                                                        }
6559
0
                                                    }
6560
                                                }
6561
0
                                            }
6562
0
                                        }
6563
0
                                    }
6564
                                }
6565
                            }
6566
0
                            _ => {}
6567
                        }
6568
                    }
6569
                    &Opcode::Fcopysign => {
6570
0
                        match v2.0 {
6571
                            F16 => {
6572
0
                                let v7 = C::unpack_value_array_2(ctx, v6);
6573
0
                                let mut v10 = C::inst_data_value_etor_returns::default();
6574
0
                                C::inst_data_value_etor(ctx, v7.1, &mut v10);
6575
0
                                let mut v10 = v10.into_context_iter();
6576
0
                                while let Some(v11) = v10.next(ctx) {
6577
0
                                    if v11.0 == F16 {
6578
                                        if let &InstructionData::UnaryIeee16 {
6579
0
                                            opcode: ref v845,
6580
0
                                            imm: v846,
6581
0
                                        } = &v11.1 {
6582
0
                                            if let &Opcode::F16const = v845 {
6583
0
                                                let mut v18 = C::inst_data_value_etor_returns::default();
6584
0
                                                C::inst_data_value_etor(ctx, v7.0, &mut v18);
6585
0
                                                let mut v18 = v18.into_context_iter();
6586
0
                                                while let Some(v19) = v18.next(ctx) {
6587
0
                                                    if v19.0 == F16 {
6588
                                                        if let &InstructionData::UnaryIeee16 {
6589
0
                                                            opcode: ref v843,
6590
0
                                                            imm: v844,
6591
0
                                                        } = &v19.1 {
6592
0
                                                            if let &Opcode::F16const = v843 {
6593
0
                                                                let v923 = C::f16_copysign(ctx, v844, v846);
6594
0
                                                                let v924 = constructor_f16const(ctx, F16, v923);
6595
0
                                                                let v925 = C::subsume(ctx, v924);
6596
                                                                // Rule at src/opts/cprop.isle line 413.
6597
0
                                                                returns.extend(Some(v925));
6598
0
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
6599
0
                                                            }
6600
0
                                                        }
6601
0
                                                    }
6602
                                                }
6603
0
                                            }
6604
0
                                        }
6605
0
                                    }
6606
                                }
6607
                            }
6608
                            F32 => {
6609
0
                                let v7 = C::unpack_value_array_2(ctx, v6);
6610
0
                                let mut v10 = C::inst_data_value_etor_returns::default();
6611
0
                                C::inst_data_value_etor(ctx, v7.1, &mut v10);
6612
0
                                let mut v10 = v10.into_context_iter();
6613
0
                                while let Some(v11) = v10.next(ctx) {
6614
0
                                    if v11.0 == F32 {
6615
                                        if let &InstructionData::UnaryIeee32 {
6616
0
                                            opcode: ref v765,
6617
0
                                            imm: v766,
6618
0
                                        } = &v11.1 {
6619
0
                                            if let &Opcode::F32const = v765 {
6620
0
                                                let mut v18 = C::inst_data_value_etor_returns::default();
6621
0
                                                C::inst_data_value_etor(ctx, v7.0, &mut v18);
6622
0
                                                let mut v18 = v18.into_context_iter();
6623
0
                                                while let Some(v19) = v18.next(ctx) {
6624
0
                                                    if v19.0 == F32 {
6625
                                                        if let &InstructionData::UnaryIeee32 {
6626
0
                                                            opcode: ref v763,
6627
0
                                                            imm: v764,
6628
0
                                                        } = &v19.1 {
6629
0
                                                            if let &Opcode::F32const = v763 {
6630
0
                                                                let v926 = C::f32_copysign(ctx, v764, v766);
6631
0
                                                                let v927 = constructor_f32const(ctx, F32, v926);
6632
0
                                                                let v928 = C::subsume(ctx, v927);
6633
                                                                // Rule at src/opts/cprop.isle line 415.
6634
0
                                                                returns.extend(Some(v928));
6635
0
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
6636
0
                                                            }
6637
0
                                                        }
6638
0
                                                    }
6639
                                                }
6640
0
                                            }
6641
0
                                        }
6642
0
                                    }
6643
                                }
6644
                            }
6645
                            F64 => {
6646
0
                                let v7 = C::unpack_value_array_2(ctx, v6);
6647
0
                                let mut v10 = C::inst_data_value_etor_returns::default();
6648
0
                                C::inst_data_value_etor(ctx, v7.1, &mut v10);
6649
0
                                let mut v10 = v10.into_context_iter();
6650
0
                                while let Some(v11) = v10.next(ctx) {
6651
0
                                    if v11.0 == F64 {
6652
                                        if let &InstructionData::UnaryIeee64 {
6653
0
                                            opcode: ref v773,
6654
0
                                            imm: v774,
6655
0
                                        } = &v11.1 {
6656
0
                                            if let &Opcode::F64const = v773 {
6657
0
                                                let mut v18 = C::inst_data_value_etor_returns::default();
6658
0
                                                C::inst_data_value_etor(ctx, v7.0, &mut v18);
6659
0
                                                let mut v18 = v18.into_context_iter();
6660
0
                                                while let Some(v19) = v18.next(ctx) {
6661
0
                                                    if v19.0 == F64 {
6662
                                                        if let &InstructionData::UnaryIeee64 {
6663
0
                                                            opcode: ref v771,
6664
0
                                                            imm: v772,
6665
0
                                                        } = &v19.1 {
6666
0
                                                            if let &Opcode::F64const = v771 {
6667
0
                                                                let v929 = C::f64_copysign(ctx, v772, v774);
6668
0
                                                                let v930 = constructor_f64const(ctx, F64, v929);
6669
0
                                                                let v931 = C::subsume(ctx, v930);
6670
                                                                // Rule at src/opts/cprop.isle line 417.
6671
0
                                                                returns.extend(Some(v931));
6672
0
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
6673
0
                                                            }
6674
0
                                                        }
6675
0
                                                    }
6676
                                                }
6677
0
                                            }
6678
0
                                        }
6679
0
                                    }
6680
                                }
6681
                            }
6682
                            F128 => {
6683
0
                                let v7 = C::unpack_value_array_2(ctx, v6);
6684
0
                                let mut v10 = C::inst_data_value_etor_returns::default();
6685
0
                                C::inst_data_value_etor(ctx, v7.1, &mut v10);
6686
0
                                let mut v10 = v10.into_context_iter();
6687
0
                                while let Some(v11) = v10.next(ctx) {
6688
0
                                    if v11.0 == F128 {
6689
                                        if let &InstructionData::UnaryConst {
6690
0
                                            opcode: ref v863,
6691
0
                                            constant_handle: v864,
6692
0
                                        } = &v11.1 {
6693
0
                                            if let &Opcode::F128const = v863 {
6694
0
                                                let v865 = C::ieee128_constant_extractor(ctx, v864);
6695
0
                                                if let Some(v866) = v865 {
6696
0
                                                    let mut v18 = C::inst_data_value_etor_returns::default();
6697
0
                                                    C::inst_data_value_etor(ctx, v7.0, &mut v18);
6698
0
                                                    let mut v18 = v18.into_context_iter();
6699
0
                                                    while let Some(v19) = v18.next(ctx) {
6700
0
                                                        if v19.0 == F128 {
6701
                                                            if let &InstructionData::UnaryConst {
6702
0
                                                                opcode: ref v859,
6703
0
                                                                constant_handle: v860,
6704
0
                                                            } = &v19.1 {
6705
0
                                                                if let &Opcode::F128const = v859 {
6706
0
                                                                    let v861 = C::ieee128_constant_extractor(ctx, v860);
6707
0
                                                                    if let Some(v862) = v861 {
6708
0
                                                                        let v932 = C::f128_copysign(ctx, v862, v866);
6709
0
                                                                        let v933 = C::ieee128_constant(ctx, v932);
6710
0
                                                                        let v934 = constructor_f128const(ctx, F128, v933);
6711
0
                                                                        let v935 = C::subsume(ctx, v934);
6712
                                                                        // Rule at src/opts/cprop.isle line 419.
6713
0
                                                                        returns.extend(Some(v935));
6714
0
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
6715
0
                                                                    }
6716
0
                                                                }
6717
0
                                                            }
6718
0
                                                        }
6719
                                                    }
6720
0
                                                }
6721
0
                                            }
6722
0
                                        }
6723
0
                                    }
6724
                                }
6725
                            }
6726
0
                            _ => {}
6727
                        }
6728
                    }
6729
                    &Opcode::Fmin => {
6730
0
                        match v2.0 {
6731
                            F16 => {
6732
0
                                let v7 = C::unpack_value_array_2(ctx, v6);
6733
0
                                let mut v10 = C::inst_data_value_etor_returns::default();
6734
0
                                C::inst_data_value_etor(ctx, v7.1, &mut v10);
6735
0
                                let mut v10 = v10.into_context_iter();
6736
0
                                while let Some(v11) = v10.next(ctx) {
6737
0
                                    if v11.0 == F16 {
6738
                                        if let &InstructionData::UnaryIeee16 {
6739
0
                                            opcode: ref v845,
6740
0
                                            imm: v846,
6741
0
                                        } = &v11.1 {
6742
0
                                            if let &Opcode::F16const = v845 {
6743
0
                                                let mut v18 = C::inst_data_value_etor_returns::default();
6744
0
                                                C::inst_data_value_etor(ctx, v7.0, &mut v18);
6745
0
                                                let mut v18 = v18.into_context_iter();
6746
0
                                                while let Some(v19) = v18.next(ctx) {
6747
0
                                                    if v19.0 == F16 {
6748
                                                        if let &InstructionData::UnaryIeee16 {
6749
0
                                                            opcode: ref v843,
6750
0
                                                            imm: v844,
6751
0
                                                        } = &v19.1 {
6752
0
                                                            if let &Opcode::F16const = v843 {
6753
0
                                                                let v847 = C::f16_min(ctx, v844, v846);
6754
0
                                                                if let Some(v848) = v847 {
6755
0
                                                                    let v849 = constructor_f16const(ctx, F32, v848);
6756
0
                                                                    let v850 = C::subsume(ctx, v849);
6757
                                                                    // Rule at src/opts/cprop.isle line 369.
6758
0
                                                                    returns.extend(Some(v850));
6759
0
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
6760
0
                                                                }
6761
0
                                                            }
6762
0
                                                        }
6763
0
                                                    }
6764
                                                }
6765
0
                                            }
6766
0
                                        }
6767
0
                                    }
6768
                                }
6769
                            }
6770
                            F32 => {
6771
0
                                let v7 = C::unpack_value_array_2(ctx, v6);
6772
0
                                let mut v10 = C::inst_data_value_etor_returns::default();
6773
0
                                C::inst_data_value_etor(ctx, v7.1, &mut v10);
6774
0
                                let mut v10 = v10.into_context_iter();
6775
0
                                while let Some(v11) = v10.next(ctx) {
6776
0
                                    if v11.0 == F32 {
6777
                                        if let &InstructionData::UnaryIeee32 {
6778
0
                                            opcode: ref v765,
6779
0
                                            imm: v766,
6780
0
                                        } = &v11.1 {
6781
0
                                            if let &Opcode::F32const = v765 {
6782
0
                                                let mut v18 = C::inst_data_value_etor_returns::default();
6783
0
                                                C::inst_data_value_etor(ctx, v7.0, &mut v18);
6784
0
                                                let mut v18 = v18.into_context_iter();
6785
0
                                                while let Some(v19) = v18.next(ctx) {
6786
0
                                                    if v19.0 == F32 {
6787
                                                        if let &InstructionData::UnaryIeee32 {
6788
0
                                                            opcode: ref v763,
6789
0
                                                            imm: v764,
6790
0
                                                        } = &v19.1 {
6791
0
                                                            if let &Opcode::F32const = v763 {
6792
0
                                                                let v851 = C::f32_min(ctx, v764, v766);
6793
0
                                                                if let Some(v852) = v851 {
6794
0
                                                                    let v853 = constructor_f32const(ctx, F32, v852);
6795
0
                                                                    let v854 = C::subsume(ctx, v853);
6796
                                                                    // Rule at src/opts/cprop.isle line 372.
6797
0
                                                                    returns.extend(Some(v854));
6798
0
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
6799
0
                                                                }
6800
0
                                                            }
6801
0
                                                        }
6802
0
                                                    }
6803
                                                }
6804
0
                                            }
6805
0
                                        }
6806
0
                                    }
6807
                                }
6808
                            }
6809
                            F64 => {
6810
0
                                let v7 = C::unpack_value_array_2(ctx, v6);
6811
0
                                let mut v10 = C::inst_data_value_etor_returns::default();
6812
0
                                C::inst_data_value_etor(ctx, v7.1, &mut v10);
6813
0
                                let mut v10 = v10.into_context_iter();
6814
0
                                while let Some(v11) = v10.next(ctx) {
6815
0
                                    if v11.0 == F64 {
6816
                                        if let &InstructionData::UnaryIeee64 {
6817
0
                                            opcode: ref v773,
6818
0
                                            imm: v774,
6819
0
                                        } = &v11.1 {
6820
0
                                            if let &Opcode::F64const = v773 {
6821
0
                                                let mut v18 = C::inst_data_value_etor_returns::default();
6822
0
                                                C::inst_data_value_etor(ctx, v7.0, &mut v18);
6823
0
                                                let mut v18 = v18.into_context_iter();
6824
0
                                                while let Some(v19) = v18.next(ctx) {
6825
0
                                                    if v19.0 == F64 {
6826
                                                        if let &InstructionData::UnaryIeee64 {
6827
0
                                                            opcode: ref v771,
6828
0
                                                            imm: v772,
6829
0
                                                        } = &v19.1 {
6830
0
                                                            if let &Opcode::F64const = v771 {
6831
0
                                                                let v855 = C::f64_min(ctx, v772, v774);
6832
0
                                                                if let Some(v856) = v855 {
6833
0
                                                                    let v857 = constructor_f64const(ctx, F64, v856);
6834
0
                                                                    let v858 = C::subsume(ctx, v857);
6835
                                                                    // Rule at src/opts/cprop.isle line 375.
6836
0
                                                                    returns.extend(Some(v858));
6837
0
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
6838
0
                                                                }
6839
0
                                                            }
6840
0
                                                        }
6841
0
                                                    }
6842
                                                }
6843
0
                                            }
6844
0
                                        }
6845
0
                                    }
6846
                                }
6847
                            }
6848
                            F128 => {
6849
0
                                let v7 = C::unpack_value_array_2(ctx, v6);
6850
0
                                let mut v10 = C::inst_data_value_etor_returns::default();
6851
0
                                C::inst_data_value_etor(ctx, v7.1, &mut v10);
6852
0
                                let mut v10 = v10.into_context_iter();
6853
0
                                while let Some(v11) = v10.next(ctx) {
6854
0
                                    if v11.0 == F128 {
6855
                                        if let &InstructionData::UnaryConst {
6856
0
                                            opcode: ref v863,
6857
0
                                            constant_handle: v864,
6858
0
                                        } = &v11.1 {
6859
0
                                            if let &Opcode::F128const = v863 {
6860
0
                                                let v865 = C::ieee128_constant_extractor(ctx, v864);
6861
0
                                                if let Some(v866) = v865 {
6862
0
                                                    let mut v18 = C::inst_data_value_etor_returns::default();
6863
0
                                                    C::inst_data_value_etor(ctx, v7.0, &mut v18);
6864
0
                                                    let mut v18 = v18.into_context_iter();
6865
0
                                                    while let Some(v19) = v18.next(ctx) {
6866
0
                                                        if v19.0 == F128 {
6867
                                                            if let &InstructionData::UnaryConst {
6868
0
                                                                opcode: ref v859,
6869
0
                                                                constant_handle: v860,
6870
0
                                                            } = &v19.1 {
6871
0
                                                                if let &Opcode::F128const = v859 {
6872
0
                                                                    let v861 = C::ieee128_constant_extractor(ctx, v860);
6873
0
                                                                    if let Some(v862) = v861 {
6874
0
                                                                        let v867 = C::f128_min(ctx, v862, v866);
6875
0
                                                                        if let Some(v868) = v867 {
6876
0
                                                                            let v870 = C::ieee128_constant(ctx, v868);
6877
0
                                                                            let v871 = constructor_f128const(ctx, F128, v870);
6878
0
                                                                            let v872 = C::subsume(ctx, v871);
6879
                                                                            // Rule at src/opts/cprop.isle line 378.
6880
0
                                                                            returns.extend(Some(v872));
6881
0
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
6882
0
                                                                        }
6883
0
                                                                    }
6884
0
                                                                }
6885
0
                                                            }
6886
0
                                                        }
6887
                                                    }
6888
0
                                                }
6889
0
                                            }
6890
0
                                        }
6891
0
                                    }
6892
                                }
6893
                            }
6894
0
                            _ => {}
6895
                        }
6896
                    }
6897
                    &Opcode::Fmax => {
6898
0
                        match v2.0 {
6899
                            F16 => {
6900
0
                                let v7 = C::unpack_value_array_2(ctx, v6);
6901
0
                                let mut v10 = C::inst_data_value_etor_returns::default();
6902
0
                                C::inst_data_value_etor(ctx, v7.1, &mut v10);
6903
0
                                let mut v10 = v10.into_context_iter();
6904
0
                                while let Some(v11) = v10.next(ctx) {
6905
0
                                    if v11.0 == F16 {
6906
                                        if let &InstructionData::UnaryIeee16 {
6907
0
                                            opcode: ref v845,
6908
0
                                            imm: v846,
6909
0
                                        } = &v11.1 {
6910
0
                                            if let &Opcode::F16const = v845 {
6911
0
                                                let mut v18 = C::inst_data_value_etor_returns::default();
6912
0
                                                C::inst_data_value_etor(ctx, v7.0, &mut v18);
6913
0
                                                let mut v18 = v18.into_context_iter();
6914
0
                                                while let Some(v19) = v18.next(ctx) {
6915
0
                                                    if v19.0 == F16 {
6916
                                                        if let &InstructionData::UnaryIeee16 {
6917
0
                                                            opcode: ref v843,
6918
0
                                                            imm: v844,
6919
0
                                                        } = &v19.1 {
6920
0
                                                            if let &Opcode::F16const = v843 {
6921
0
                                                                let v873 = C::f16_max(ctx, v844, v846);
6922
0
                                                                if let Some(v874) = v873 {
6923
0
                                                                    let v876 = constructor_f16const(ctx, F16, v874);
6924
0
                                                                    let v877 = C::subsume(ctx, v876);
6925
                                                                    // Rule at src/opts/cprop.isle line 382.
6926
0
                                                                    returns.extend(Some(v877));
6927
0
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
6928
0
                                                                }
6929
0
                                                            }
6930
0
                                                        }
6931
0
                                                    }
6932
                                                }
6933
0
                                            }
6934
0
                                        }
6935
0
                                    }
6936
                                }
6937
                            }
6938
                            F32 => {
6939
0
                                let v7 = C::unpack_value_array_2(ctx, v6);
6940
0
                                let mut v10 = C::inst_data_value_etor_returns::default();
6941
0
                                C::inst_data_value_etor(ctx, v7.1, &mut v10);
6942
0
                                let mut v10 = v10.into_context_iter();
6943
0
                                while let Some(v11) = v10.next(ctx) {
6944
0
                                    if v11.0 == F32 {
6945
                                        if let &InstructionData::UnaryIeee32 {
6946
0
                                            opcode: ref v765,
6947
0
                                            imm: v766,
6948
0
                                        } = &v11.1 {
6949
0
                                            if let &Opcode::F32const = v765 {
6950
0
                                                let mut v18 = C::inst_data_value_etor_returns::default();
6951
0
                                                C::inst_data_value_etor(ctx, v7.0, &mut v18);
6952
0
                                                let mut v18 = v18.into_context_iter();
6953
0
                                                while let Some(v19) = v18.next(ctx) {
6954
0
                                                    if v19.0 == F32 {
6955
                                                        if let &InstructionData::UnaryIeee32 {
6956
0
                                                            opcode: ref v763,
6957
0
                                                            imm: v764,
6958
0
                                                        } = &v19.1 {
6959
0
                                                            if let &Opcode::F32const = v763 {
6960
0
                                                                let v878 = C::f32_max(ctx, v764, v766);
6961
0
                                                                if let Some(v879) = v878 {
6962
0
                                                                    let v880 = constructor_f32const(ctx, F32, v879);
6963
0
                                                                    let v881 = C::subsume(ctx, v880);
6964
                                                                    // Rule at src/opts/cprop.isle line 385.
6965
0
                                                                    returns.extend(Some(v881));
6966
0
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
6967
0
                                                                }
6968
0
                                                            }
6969
0
                                                        }
6970
0
                                                    }
6971
                                                }
6972
0
                                            }
6973
0
                                        }
6974
0
                                    }
6975
                                }
6976
                            }
6977
                            F64 => {
6978
0
                                let v7 = C::unpack_value_array_2(ctx, v6);
6979
0
                                let mut v10 = C::inst_data_value_etor_returns::default();
6980
0
                                C::inst_data_value_etor(ctx, v7.1, &mut v10);
6981
0
                                let mut v10 = v10.into_context_iter();
6982
0
                                while let Some(v11) = v10.next(ctx) {
6983
0
                                    if v11.0 == F64 {
6984
                                        if let &InstructionData::UnaryIeee64 {
6985
0
                                            opcode: ref v773,
6986
0
                                            imm: v774,
6987
0
                                        } = &v11.1 {
6988
0
                                            if let &Opcode::F64const = v773 {
6989
0
                                                let mut v18 = C::inst_data_value_etor_returns::default();
6990
0
                                                C::inst_data_value_etor(ctx, v7.0, &mut v18);
6991
0
                                                let mut v18 = v18.into_context_iter();
6992
0
                                                while let Some(v19) = v18.next(ctx) {
6993
0
                                                    if v19.0 == F64 {
6994
                                                        if let &InstructionData::UnaryIeee64 {
6995
0
                                                            opcode: ref v771,
6996
0
                                                            imm: v772,
6997
0
                                                        } = &v19.1 {
6998
0
                                                            if let &Opcode::F64const = v771 {
6999
0
                                                                let v882 = C::f64_max(ctx, v772, v774);
7000
0
                                                                if let Some(v883) = v882 {
7001
0
                                                                    let v884 = constructor_f64const(ctx, F64, v883);
7002
0
                                                                    let v885 = C::subsume(ctx, v884);
7003
                                                                    // Rule at src/opts/cprop.isle line 388.
7004
0
                                                                    returns.extend(Some(v885));
7005
0
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
7006
0
                                                                }
7007
0
                                                            }
7008
0
                                                        }
7009
0
                                                    }
7010
                                                }
7011
0
                                            }
7012
0
                                        }
7013
0
                                    }
7014
                                }
7015
                            }
7016
                            F128 => {
7017
0
                                let v7 = C::unpack_value_array_2(ctx, v6);
7018
0
                                let mut v10 = C::inst_data_value_etor_returns::default();
7019
0
                                C::inst_data_value_etor(ctx, v7.1, &mut v10);
7020
0
                                let mut v10 = v10.into_context_iter();
7021
0
                                while let Some(v11) = v10.next(ctx) {
7022
0
                                    if v11.0 == F128 {
7023
                                        if let &InstructionData::UnaryConst {
7024
0
                                            opcode: ref v863,
7025
0
                                            constant_handle: v864,
7026
0
                                        } = &v11.1 {
7027
0
                                            if let &Opcode::F128const = v863 {
7028
0
                                                let v865 = C::ieee128_constant_extractor(ctx, v864);
7029
0
                                                if let Some(v866) = v865 {
7030
0
                                                    let mut v18 = C::inst_data_value_etor_returns::default();
7031
0
                                                    C::inst_data_value_etor(ctx, v7.0, &mut v18);
7032
0
                                                    let mut v18 = v18.into_context_iter();
7033
0
                                                    while let Some(v19) = v18.next(ctx) {
7034
0
                                                        if v19.0 == F128 {
7035
                                                            if let &InstructionData::UnaryConst {
7036
0
                                                                opcode: ref v859,
7037
0
                                                                constant_handle: v860,
7038
0
                                                            } = &v19.1 {
7039
0
                                                                if let &Opcode::F128const = v859 {
7040
0
                                                                    let v861 = C::ieee128_constant_extractor(ctx, v860);
7041
0
                                                                    if let Some(v862) = v861 {
7042
0
                                                                        let v886 = C::f128_max(ctx, v862, v866);
7043
0
                                                                        if let Some(v887) = v886 {
7044
0
                                                                            let v888 = C::ieee128_constant(ctx, v887);
7045
0
                                                                            let v889 = constructor_f128const(ctx, F128, v888);
7046
0
                                                                            let v890 = C::subsume(ctx, v889);
7047
                                                                            // Rule at src/opts/cprop.isle line 391.
7048
0
                                                                            returns.extend(Some(v890));
7049
0
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
7050
0
                                                                        }
7051
0
                                                                    }
7052
0
                                                                }
7053
0
                                                            }
7054
0
                                                        }
7055
                                                    }
7056
0
                                                }
7057
0
                                            }
7058
0
                                        }
7059
0
                                    }
7060
                                }
7061
                            }
7062
0
                            _ => {}
7063
                        }
7064
                    }
7065
                    &Opcode::Iconcat => {
7066
3.25k
                        if v2.0 == I128 {
7067
3.25k
                            let v7 = C::unpack_value_array_2(ctx, v6);
7068
3.25k
                            let mut v10 = C::inst_data_value_etor_returns::default();
7069
3.25k
                            C::inst_data_value_etor(ctx, v7.1, &mut v10);
7070
3.25k
                            let mut v10 = v10.into_context_iter();
7071
6.29k
                            while let Some(
v113.04k
) = v10.next(ctx) {
7072
3.04k
                                match &v11.1 {
7073
                                    &InstructionData::Binary {
7074
1.09k
                                        opcode: ref v104,
7075
1.09k
                                        args: ref v105,
7076
                                    } => {
7077
1.09k
                                        if let &Opcode::Sshr = v104 {
7078
0
                                            let v106 = C::unpack_value_array_2(ctx, v105);
7079
0
                                            if v7.0 == v106.0 {
7080
0
                                                let mut v109 = C::inst_data_value_etor_returns::default();
7081
0
                                                C::inst_data_value_etor(ctx, v106.1, &mut v109);
7082
0
                                                let mut v109 = v109.into_context_iter();
7083
0
                                                while let Some(v110) = v109.next(ctx) {
7084
                                                    if let &InstructionData::UnaryImm {
7085
0
                                                        opcode: ref v724,
7086
0
                                                        imm: v725,
7087
0
                                                    } = &v110.1 {
7088
0
                                                        if let &Opcode::Iconst = v724 {
7089
0
                                                            let v994 = C::u64_from_imm64(ctx, v725);
7090
0
                                                            if v994 == 0x3f_u64 {
7091
0
                                                                let v995 = constructor_sextend(ctx, I128, v7.0);
7092
                                                                // Rule at src/opts/extends.isle line 94.
7093
0
                                                                returns.extend(Some(v995));
7094
0
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
7095
0
                                                            }
7096
0
                                                        }
7097
0
                                                    }
7098
                                                }
7099
0
                                            }
7100
1.09k
                                        }
7101
                                    }
7102
                                    &InstructionData::UnaryImm {
7103
1
                                        opcode: ref v14,
7104
1
                                        imm: v15,
7105
                                    } => {
7106
1
                                        if let &Opcode::Iconst = v14 {
7107
1
                                            let v16 = C::u64_from_imm64(ctx, v15);
7108
1
                                            if v16 == 0x0_u64 {
7109
0
                                                let v993 = constructor_uextend(ctx, I128, v7.0);
7110
                                                // Rule at src/opts/extends.isle line 93.
7111
0
                                                returns.extend(Some(v993));
7112
0
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
7113
1
                                            }
7114
0
                                        }
7115
                                    }
7116
1.95k
                                    _ => {}
7117
                                }
7118
                            }
7119
0
                        }
7120
                    }
7121
0
                    _ => {}
7122
                }
7123
            }
7124
            &InstructionData::IntCompare {
7125
338k
                opcode: ref v268,
7126
338k
                args: ref v269,
7127
338k
                cond: ref v270,
7128
            } => {
7129
338k
                if let &Opcode::Icmp = v268 {
7130
338k
                    match v270 {
7131
                        &IntCC::Equal => {
7132
163k
                            let v271 = C::unpack_value_array_2(ctx, v269);
7133
163k
                            let mut v598 = C::inst_data_value_etor_returns::default();
7134
163k
                            C::inst_data_value_etor(ctx, v271.0, &mut v598);
7135
163k
                            let mut v598 = v598.into_context_iter();
7136
321k
                            while let Some(
v599158k
) = v598.next(ctx) {
7137
158k
                                match &v599.1 {
7138
                                    &InstructionData::Binary {
7139
21.9k
                                        opcode: ref v653,
7140
21.9k
                                        args: ref v654,
7141
                                    } => {
7142
21.9k
                                        match v653 {
7143
                                            &Opcode::Iadd => {
7144
4.39k
                                                let mut v274 = C::inst_data_value_etor_returns::default();
7145
4.39k
                                                C::inst_data_value_etor(ctx, v271.1, &mut v274);
7146
4.39k
                                                let mut v274 = v274.into_context_iter();
7147
8.64k
                                                while let Some(
v2754.25k
) = v274.next(ctx) {
7148
4.25k
                                                    match &v275.1 {
7149
                                                        &InstructionData::Binary {
7150
277
                                                            opcode: ref v670,
7151
277
                                                            args: ref v671,
7152
                                                        } => {
7153
277
                                                            if let &Opcode::Iadd = v670 {
7154
272
                                                                let v655 = C::unpack_value_array_2(ctx, v654);
7155
272
                                                                let v672 = C::unpack_value_array_2(ctx, v671);
7156
272
                                                                if v655.0 == v672.0 {
7157
120
                                                                    let v1004 = constructor_eq(ctx, v2.0, v655.1, v672.1);
7158
120
                                                                    let v1005 = C::subsume(ctx, v1004);
7159
                                                                    // Rule at src/opts/icmp.isle line 26.
7160
120
                                                                    returns.extend(Some(v1005));
7161
120
                                                                    if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
7162
152
                                                                }
7163
272
                                                                if v655.0 == v672.1 {
7164
0
                                                                    let v1002 = constructor_eq(ctx, v2.0, v655.1, v672.0);
7165
0
                                                                    let v1003 = C::subsume(ctx, v1002);
7166
                                                                    // Rule at src/opts/icmp.isle line 24.
7167
0
                                                                    returns.extend(Some(v1003));
7168
0
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
7169
272
                                                                }
7170
272
                                                                if v655.1 == v672.0 {
7171
0
                                                                    let v1000 = constructor_eq(ctx, v2.0, v655.0, v672.1);
7172
0
                                                                    let v1001 = C::subsume(ctx, v1000);
7173
                                                                    // Rule at src/opts/icmp.isle line 22.
7174
0
                                                                    returns.extend(Some(v1001));
7175
0
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
7176
272
                                                                }
7177
272
                                                                if v655.1 == v672.1 {
7178
3
                                                                    let v998 = constructor_eq(ctx, v2.0, v655.0, v672.0);
7179
3
                                                                    let v999 = C::subsume(ctx, v998);
7180
                                                                    // Rule at src/opts/icmp.isle line 20.
7181
3
                                                                    returns.extend(Some(v999));
7182
3
                                                                    if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
7183
269
                                                                }
7184
272
                                                                let mut v658 = C::inst_data_value_etor_returns::default();
7185
272
                                                                C::inst_data_value_etor(ctx, v655.1, &mut v658);
7186
272
                                                                let mut v658 = v658.into_context_iter();
7187
609
                                                                while let Some(
v659337
) = v658.next(ctx) {
7188
                                                                    if let &InstructionData::UnaryImm {
7189
120
                                                                        opcode: ref v662,
7190
120
                                                                        imm: v663,
7191
337
                                                                    } = &v659.1 {
7192
120
                                                                        if let &Opcode::Iconst = v662 {
7193
120
                                                                            let mut v675 = C::inst_data_value_etor_returns::default();
7194
120
                                                                            C::inst_data_value_etor(ctx, v672.1, &mut v675);
7195
120
                                                                            let mut v675 = v675.into_context_iter();
7196
191
                                                                            while let Some(
v67671
) = v675.next(ctx) {
7197
                                                                                if let &InstructionData::UnaryImm {
7198
42
                                                                                    opcode: ref v679,
7199
42
                                                                                    imm: v680,
7200
71
                                                                                } = &v676.1 {
7201
42
                                                                                    if let &Opcode::Iconst = v679 {
7202
42
                                                                                        let v681 = constructor_isub(ctx, v275.0, v672.1, v655.1);
7203
42
                                                                                        let v682 = constructor_iadd(ctx, v599.0, v672.0, v681);
7204
42
                                                                                        let v683 = constructor_eq(ctx, v2.0, v655.0, v682);
7205
                                                                                        // Rule at src/opts/cprop.isle line 184.
7206
42
                                                                                        returns.extend(Some(v683));
7207
42
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
7208
0
                                                                                    }
7209
29
                                                                                }
7210
                                                                            }
7211
0
                                                                        }
7212
217
                                                                    }
7213
                                                                }
7214
5
                                                            }
7215
                                                        }
7216
                                                        &InstructionData::UnaryImm {
7217
3.14k
                                                            opcode: ref v278,
7218
3.14k
                                                            imm: v279,
7219
                                                        } => {
7220
3.14k
                                                            if let &Opcode::Iconst = v278 {
7221
3.14k
                                                                let v655 = C::unpack_value_array_2(ctx, v654);
7222
3.14k
                                                                let mut v658 = C::inst_data_value_etor_returns::default();
7223
3.14k
                                                                C::inst_data_value_etor(ctx, v655.1, &mut v658);
7224
3.14k
                                                                let mut v658 = v658.into_context_iter();
7225
6.34k
                                                                while let Some(
v6593.19k
) = v658.next(ctx) {
7226
                                                                    if let &InstructionData::UnaryImm {
7227
2.88k
                                                                        opcode: ref v662,
7228
2.88k
                                                                        imm: v663,
7229
3.19k
                                                                    } = &v659.1 {
7230
2.88k
                                                                        if let &Opcode::Iconst = v662 {
7231
2.88k
                                                                            let v664 = constructor_isub(ctx, v599.0, v271.1, v655.1);
7232
2.88k
                                                                            let v665 = constructor_eq(ctx, v2.0, v655.0, v664);
7233
                                                                            // Rule at src/opts/cprop.isle line 174.
7234
2.88k
                                                                            returns.extend(Some(v665));
7235
2.88k
                                                                            if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
7236
0
                                                                        }
7237
309
                                                                    }
7238
                                                                }
7239
0
                                                            }
7240
                                                        }
7241
827
                                                        _ => {}
7242
                                                    }
7243
                                                }
7244
                                            }
7245
                                            &Opcode::Isub => {
7246
1.32k
                                                let v655 = C::unpack_value_array_2(ctx, v654);
7247
1.32k
                                                let mut v658 = C::inst_data_value_etor_returns::default();
7248
1.32k
                                                C::inst_data_value_etor(ctx, v655.1, &mut v658);
7249
1.32k
                                                let mut v658 = v658.into_context_iter();
7250
2.65k
                                                while let Some(
v6591.32k
) = v658.next(ctx) {
7251
1.32k
                                                    match &v659.1 {
7252
                                                        &InstructionData::IntCompare {
7253
2
                                                            opcode: ref v1360,
7254
2
                                                            args: ref v1361,
7255
2
                                                            cond: ref v1362,
7256
                                                        } => {
7257
2
                                                            if let &Opcode::Icmp = v1360 {
7258
2
                                                                match v1362 {
7259
                                                                    &IntCC::SignedLessThan => {
7260
0
                                                                        if v599.0 == I8 {
7261
0
                                                                            let mut v953 = C::inst_data_value_tupled_etor_returns::default();
7262
0
                                                                            C::inst_data_value_tupled_etor(ctx, v271.1, &mut v953);
7263
0
                                                                            let mut v953 = v953.into_context_iter();
7264
0
                                                                            while let Some(v954) = v953.next(ctx) {
7265
0
                                                                                let v955 = C::iconst_sextend_etor(ctx, v954);
7266
0
                                                                                if let Some(v956) = v955 {
7267
0
                                                                                    match v956.1 {
7268
                                                                                        -1_i64 => {
7269
0
                                                                                            let mut v1350 = C::inst_data_value_etor_returns::default();
7270
0
                                                                                            C::inst_data_value_etor(ctx, v655.0, &mut v1350);
7271
0
                                                                                            let mut v1350 = v1350.into_context_iter();
7272
0
                                                                                            while let Some(v1351) = v1350.next(ctx) {
7273
                                                                                                if let &InstructionData::IntCompare {
7274
0
                                                                                                    opcode: ref v1354,
7275
0
                                                                                                    args: ref v1355,
7276
0
                                                                                                    cond: ref v1356,
7277
0
                                                                                                } = &v1351.1 {
7278
0
                                                                                                    if let &Opcode::Icmp = v1354 {
7279
0
                                                                                                        if let &IntCC::SignedGreaterThan = v1356 {
7280
0
                                                                                                            if v659.0 == v1351.0 {
7281
0
                                                                                                                let v1357 = C::unpack_value_array_2(ctx, v1355);
7282
0
                                                                                                                let v1363 = C::unpack_value_array_2(ctx, v1361);
7283
0
                                                                                                                if v1357.0 == v1363.0 {
7284
0
                                                                                                                    if v1357.1 == v1363.1 {
7285
0
                                                                                                                        let v1368 = constructor_slt(ctx, v1351.0, v1357.0, v1357.1);
7286
                                                                                                                        // Rule at src/opts/spaceship.isle line 178.
7287
0
                                                                                                                        returns.extend(Some(v1368));
7288
0
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
7289
0
                                                                                                                    }
7290
0
                                                                                                                }
7291
0
                                                                                                            }
7292
0
                                                                                                        }
7293
0
                                                                                                    }
7294
0
                                                                                                }
7295
                                                                                            }
7296
                                                                                        }
7297
                                                                                        0_i64 => {
7298
0
                                                                                            let mut v1350 = C::inst_data_value_etor_returns::default();
7299
0
                                                                                            C::inst_data_value_etor(ctx, v655.0, &mut v1350);
7300
0
                                                                                            let mut v1350 = v1350.into_context_iter();
7301
0
                                                                                            while let Some(v1351) = v1350.next(ctx) {
7302
                                                                                                if let &InstructionData::IntCompare {
7303
0
                                                                                                    opcode: ref v1354,
7304
0
                                                                                                    args: ref v1355,
7305
0
                                                                                                    cond: ref v1356,
7306
0
                                                                                                } = &v1351.1 {
7307
0
                                                                                                    if let &Opcode::Icmp = v1354 {
7308
0
                                                                                                        if let &IntCC::SignedGreaterThan = v1356 {
7309
0
                                                                                                            if v659.0 == v1351.0 {
7310
0
                                                                                                                let v1357 = C::unpack_value_array_2(ctx, v1355);
7311
0
                                                                                                                let v1363 = C::unpack_value_array_2(ctx, v1361);
7312
0
                                                                                                                if v1357.0 == v1363.0 {
7313
0
                                                                                                                    if v1357.1 == v1363.1 {
7314
0
                                                                                                                        let v1366 = constructor_eq(ctx, v1351.0, v1357.0, v1357.1);
7315
                                                                                                                        // Rule at src/opts/spaceship.isle line 145.
7316
0
                                                                                                                        returns.extend(Some(v1366));
7317
0
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
7318
0
                                                                                                                    }
7319
0
                                                                                                                }
7320
0
                                                                                                            }
7321
0
                                                                                                        }
7322
0
                                                                                                    }
7323
0
                                                                                                }
7324
                                                                                            }
7325
                                                                                        }
7326
                                                                                        1_i64 => {
7327
0
                                                                                            let mut v1350 = C::inst_data_value_etor_returns::default();
7328
0
                                                                                            C::inst_data_value_etor(ctx, v655.0, &mut v1350);
7329
0
                                                                                            let mut v1350 = v1350.into_context_iter();
7330
0
                                                                                            while let Some(v1351) = v1350.next(ctx) {
7331
                                                                                                if let &InstructionData::IntCompare {
7332
0
                                                                                                    opcode: ref v1354,
7333
0
                                                                                                    args: ref v1355,
7334
0
                                                                                                    cond: ref v1356,
7335
0
                                                                                                } = &v1351.1 {
7336
0
                                                                                                    if let &Opcode::Icmp = v1354 {
7337
0
                                                                                                        if let &IntCC::SignedGreaterThan = v1356 {
7338
0
                                                                                                            if v659.0 == v1351.0 {
7339
0
                                                                                                                let v1357 = C::unpack_value_array_2(ctx, v1355);
7340
0
                                                                                                                let v1363 = C::unpack_value_array_2(ctx, v1361);
7341
0
                                                                                                                if v1357.0 == v1363.0 {
7342
0
                                                                                                                    if v1357.1 == v1363.1 {
7343
0
                                                                                                                        let v1372 = constructor_sgt(ctx, v1351.0, v1357.0, v1357.1);
7344
                                                                                                                        // Rule at src/opts/spaceship.isle line 186.
7345
0
                                                                                                                        returns.extend(Some(v1372));
7346
0
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
7347
0
                                                                                                                    }
7348
0
                                                                                                                }
7349
0
                                                                                                            }
7350
0
                                                                                                        }
7351
0
                                                                                                    }
7352
0
                                                                                                }
7353
                                                                                            }
7354
                                                                                        }
7355
0
                                                                                        _ => {}
7356
                                                                                    }
7357
0
                                                                                }
7358
                                                                            }
7359
0
                                                                        }
7360
                                                                    }
7361
                                                                    &IntCC::UnsignedLessThan => {
7362
2
                                                                        if v599.0 == I8 {
7363
2
                                                                            let mut v953 = C::inst_data_value_tupled_etor_returns::default();
7364
2
                                                                            C::inst_data_value_tupled_etor(ctx, v271.1, &mut v953);
7365
2
                                                                            let mut v953 = v953.into_context_iter();
7366
4
                                                                            while let Some(
v9542
) = v953.next(ctx) {
7367
2
                                                                                let v955 = C::iconst_sextend_etor(ctx, v954);
7368
2
                                                                                if let Some(v956) = v955 {
7369
2
                                                                                    match v956.1 {
7370
                                                                                        -1_i64 => {
7371
0
                                                                                            let mut v1350 = C::inst_data_value_etor_returns::default();
7372
0
                                                                                            C::inst_data_value_etor(ctx, v655.0, &mut v1350);
7373
0
                                                                                            let mut v1350 = v1350.into_context_iter();
7374
0
                                                                                            while let Some(v1351) = v1350.next(ctx) {
7375
                                                                                                if let &InstructionData::IntCompare {
7376
0
                                                                                                    opcode: ref v1354,
7377
0
                                                                                                    args: ref v1355,
7378
0
                                                                                                    cond: ref v1356,
7379
0
                                                                                                } = &v1351.1 {
7380
0
                                                                                                    if let &Opcode::Icmp = v1354 {
7381
0
                                                                                                        if let &IntCC::UnsignedGreaterThan = v1356 {
7382
0
                                                                                                            if v659.0 == v1351.0 {
7383
0
                                                                                                                let v1357 = C::unpack_value_array_2(ctx, v1355);
7384
0
                                                                                                                let v1363 = C::unpack_value_array_2(ctx, v1361);
7385
0
                                                                                                                if v1357.0 == v1363.0 {
7386
0
                                                                                                                    if v1357.1 == v1363.1 {
7387
0
                                                                                                                        let v1369 = constructor_ult(ctx, v1351.0, v1357.0, v1357.1);
7388
                                                                                                                        // Rule at src/opts/spaceship.isle line 180.
7389
0
                                                                                                                        returns.extend(Some(v1369));
7390
0
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
7391
0
                                                                                                                    }
7392
0
                                                                                                                }
7393
0
                                                                                                            }
7394
0
                                                                                                        }
7395
0
                                                                                                    }
7396
0
                                                                                                }
7397
                                                                                            }
7398
                                                                                        }
7399
                                                                                        0_i64 => {
7400
2
                                                                                            let mut v1350 = C::inst_data_value_etor_returns::default();
7401
2
                                                                                            C::inst_data_value_etor(ctx, v655.0, &mut v1350);
7402
2
                                                                                            let mut v1350 = v1350.into_context_iter();
7403
4
                                                                                            while let Some(
v13512
) = v1350.next(ctx) {
7404
                                                                                                if let &InstructionData::IntCompare {
7405
2
                                                                                                    opcode: ref v1354,
7406
2
                                                                                                    args: ref v1355,
7407
2
                                                                                                    cond: ref v1356,
7408
2
                                                                                                } = &v1351.1 {
7409
2
                                                                                                    if let &Opcode::Icmp = v1354 {
7410
2
                                                                                                        if let &IntCC::UnsignedGreaterThan = v1356 {
7411
2
                                                                                                            if v659.0 == v1351.0 {
7412
2
                                                                                                                let v1357 = C::unpack_value_array_2(ctx, v1355);
7413
2
                                                                                                                let v1363 = C::unpack_value_array_2(ctx, v1361);
7414
2
                                                                                                                if v1357.0 == v1363.0 {
7415
2
                                                                                                                    if v1357.1 == v1363.1 {
7416
2
                                                                                                                        let v1366 = constructor_eq(ctx, v1351.0, v1357.0, v1357.1);
7417
                                                                                                                        // Rule at src/opts/spaceship.isle line 147.
7418
2
                                                                                                                        returns.extend(Some(v1366));
7419
2
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
7420
0
                                                                                                                    }
7421
0
                                                                                                                }
7422
0
                                                                                                            }
7423
0
                                                                                                        }
7424
0
                                                                                                    }
7425
0
                                                                                                }
7426
                                                                                            }
7427
                                                                                        }
7428
                                                                                        1_i64 => {
7429
0
                                                                                            let mut v1350 = C::inst_data_value_etor_returns::default();
7430
0
                                                                                            C::inst_data_value_etor(ctx, v655.0, &mut v1350);
7431
0
                                                                                            let mut v1350 = v1350.into_context_iter();
7432
0
                                                                                            while let Some(v1351) = v1350.next(ctx) {
7433
                                                                                                if let &InstructionData::IntCompare {
7434
0
                                                                                                    opcode: ref v1354,
7435
0
                                                                                                    args: ref v1355,
7436
0
                                                                                                    cond: ref v1356,
7437
0
                                                                                                } = &v1351.1 {
7438
0
                                                                                                    if let &Opcode::Icmp = v1354 {
7439
0
                                                                                                        if let &IntCC::UnsignedGreaterThan = v1356 {
7440
0
                                                                                                            if v659.0 == v1351.0 {
7441
0
                                                                                                                let v1357 = C::unpack_value_array_2(ctx, v1355);
7442
0
                                                                                                                let v1363 = C::unpack_value_array_2(ctx, v1361);
7443
0
                                                                                                                if v1357.0 == v1363.0 {
7444
0
                                                                                                                    if v1357.1 == v1363.1 {
7445
0
                                                                                                                        let v1373 = constructor_ugt(ctx, v1351.0, v1357.0, v1357.1);
7446
                                                                                                                        // Rule at src/opts/spaceship.isle line 188.
7447
0
                                                                                                                        returns.extend(Some(v1373));
7448
0
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
7449
0
                                                                                                                    }
7450
0
                                                                                                                }
7451
0
                                                                                                            }
7452
0
                                                                                                        }
7453
0
                                                                                                    }
7454
0
                                                                                                }
7455
                                                                                            }
7456
                                                                                        }
7457
0
                                                                                        _ => {}
7458
                                                                                    }
7459
0
                                                                                }
7460
                                                                            }
7461
0
                                                                        }
7462
                                                                    }
7463
0
                                                                    _ => {}
7464
                                                                }
7465
0
                                                            }
7466
                                                        }
7467
                                                        &InstructionData::UnaryImm {
7468
0
                                                            opcode: ref v662,
7469
0
                                                            imm: v663,
7470
                                                        } => {
7471
0
                                                            if let &Opcode::Iconst = v662 {
7472
0
                                                                let mut v274 = C::inst_data_value_etor_returns::default();
7473
0
                                                                C::inst_data_value_etor(ctx, v271.1, &mut v274);
7474
0
                                                                let mut v274 = v274.into_context_iter();
7475
0
                                                                while let Some(v275) = v274.next(ctx) {
7476
                                                                    if let &InstructionData::UnaryImm {
7477
0
                                                                        opcode: ref v278,
7478
0
                                                                        imm: v279,
7479
0
                                                                    } = &v275.1 {
7480
0
                                                                        if let &Opcode::Iconst = v278 {
7481
0
                                                                            let v667 = constructor_iadd(ctx, v599.0, v271.1, v655.1);
7482
0
                                                                            let v668 = constructor_eq(ctx, v2.0, v655.0, v667);
7483
                                                                            // Rule at src/opts/cprop.isle line 179.
7484
0
                                                                            returns.extend(Some(v668));
7485
0
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
7486
0
                                                                        }
7487
0
                                                                    }
7488
                                                                }
7489
0
                                                            }
7490
                                                        }
7491
1.32k
                                                        _ => {}
7492
                                                    }
7493
                                                }
7494
1.32k
                                                let mut v274 = C::inst_data_value_etor_returns::default();
7495
1.32k
                                                C::inst_data_value_etor(ctx, v271.1, &mut v274);
7496
1.32k
                                                let mut v274 = v274.into_context_iter();
7497
2.55k
                                                while let Some(
v2751.22k
) = v274.next(ctx) {
7498
                                                    if let &InstructionData::Binary {
7499
103
                                                        opcode: ref v670,
7500
103
                                                        args: ref v671,
7501
1.22k
                                                    } = &v275.1 {
7502
103
                                                        if let &Opcode::Isub = v670 {
7503
69
                                                            let v672 = C::unpack_value_array_2(ctx, v671);
7504
69
                                                            let v1014 = constructor_iadd(ctx, v599.0, v655.0, v672.1);
7505
69
                                                            let v1015 = constructor_iadd(ctx, v275.0, v672.0, v655.1);
7506
69
                                                            let v1016 = constructor_eq(ctx, v2.0, v1014, v1015);
7507
                                                            // Rule at src/opts/icmp.isle line 40.
7508
69
                                                            returns.extend(Some(v1016));
7509
69
                                                            if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
7510
34
                                                        }
7511
1.12k
                                                    }
7512
                                                }
7513
                                            }
7514
16.2k
                                            _ => {}
7515
                                        }
7516
                                    }
7517
                                    &InstructionData::Unary {
7518
6.31k
                                        opcode: ref v945,
7519
6.31k
                                        arg: v946,
7520
                                    } => {
7521
6.31k
                                        if let &Opcode::Sextend = v945 {
7522
88
                                            let mut v953 = C::inst_data_value_tupled_etor_returns::default();
7523
88
                                            C::inst_data_value_tupled_etor(ctx, v271.1, &mut v953);
7524
88
                                            let mut v953 = v953.into_context_iter();
7525
176
                                            while let Some(
v95488
) = v953.next(ctx) {
7526
88
                                                let v955 = C::iconst_sextend_etor(ctx, v954);
7527
88
                                                if let Some(v956) = v955 {
7528
88
                                                    if v956.1 == 0_i64 {
7529
2
                                                        let v947 = C::value_type(ctx, v946);
7530
2
                                                        let v960 = constructor_iconst_s(ctx, v947, 0_i64);
7531
2
                                                        let v961 = constructor_eq(ctx, v947, v946, v960);
7532
                                                        // Rule at src/opts/extends.isle line 39.
7533
2
                                                        returns.extend(Some(v961));
7534
2
                                                        if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
7535
86
                                                    }
7536
0
                                                }
7537
                                            }
7538
6.23k
                                        }
7539
                                    }
7540
129k
                                    _ => {}
7541
                                }
7542
                            }
7543
163k
                            let mut v274 = C::inst_data_value_etor_returns::default();
7544
163k
                            C::inst_data_value_etor(ctx, v271.1, &mut v274);
7545
163k
                            let mut v274 = v274.into_context_iter();
7546
326k
                            while let Some(
v275162k
) = v274.next(ctx) {
7547
162k
                                match &v275.1 {
7548
                                    &InstructionData::Binary {
7549
1.80k
                                        opcode: ref v670,
7550
1.80k
                                        args: ref v671,
7551
                                    } => {
7552
1.80k
                                        if let &Opcode::Bxor = v670 {
7553
0
                                            let v1135 = C::ty_int(ctx, v275.0);
7554
0
                                            if let Some(v1136) = v1135 {
7555
0
                                                let v672 = C::unpack_value_array_2(ctx, v671);
7556
0
                                                if v271.0 == v672.0 {
7557
0
                                                    let v1137 = constructor_iconst_u(ctx, v1136, 0x0_u64);
7558
0
                                                    let v1138 = constructor_eq(ctx, v2.0, v672.1, v1137);
7559
0
                                                    let v1139 = C::subsume(ctx, v1138);
7560
                                                    // Rule at src/opts/icmp.isle line 290.
7561
0
                                                    returns.extend(Some(v1139));
7562
0
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
7563
0
                                                }
7564
0
                                            }
7565
1.80k
                                        }
7566
                                    }
7567
                                    &InstructionData::UnaryImm {
7568
127k
                                        opcode: ref v278,
7569
127k
                                        imm: v279,
7570
                                    } => {
7571
127k
                                        if let &Opcode::Iconst = v278 {
7572
127k
                                            let v280 = C::u64_from_imm64(ctx, v279);
7573
127k
                                            match v280 {
7574
                                                0x0_u64 => {
7575
105k
                                                    let mut v1018 = C::uextend_maybe_etor_returns::default();
7576
105k
                                                    C::uextend_maybe_etor(ctx, v271.0, &mut v1018);
7577
105k
                                                    let mut v1018 = v1018.into_context_iter();
7578
210k
                                                    while let Some(
v1019105k
) = v1018.next(ctx) {
7579
105k
                                                        let mut v1022 = C::inst_data_value_etor_returns::default();
7580
105k
                                                        C::inst_data_value_etor(ctx, v1019.1, &mut v1022);
7581
105k
                                                        let mut v1022 = v1022.into_context_iter();
7582
207k
                                                        while let Some(
v1023101k
) = v1022.next(ctx) {
7583
                                                            if let &InstructionData::IntCompare {
7584
1.46k
                                                                opcode: ref v1026,
7585
1.46k
                                                                args: ref v1027,
7586
1.46k
                                                                cond: ref v1028,
7587
101k
                                                            } = &v1023.1 {
7588
1.46k
                                                                if let &Opcode::Icmp = v1026 {
7589
1.46k
                                                                    if v2.0 == v1023.0 {
7590
1.46k
                                                                        let v1033 = &C::intcc_complement(ctx, v1028);
7591
1.46k
                                                                        let v1029 = C::unpack_value_array_2(ctx, v1027);
7592
1.46k
                                                                        let v1034 = constructor_icmp(ctx, v2.0, v1033, v1029.0, v1029.1);
7593
1.46k
                                                                        let v1035 = C::subsume(ctx, v1034);
7594
                                                                        // Rule at src/opts/icmp.isle line 55.
7595
1.46k
                                                                        returns.extend(Some(v1035));
7596
1.46k
                                                                        if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
7597
0
                                                                    }
7598
0
                                                                }
7599
100k
                                                            }
7600
                                                        }
7601
                                                    }
7602
                                                }
7603
                                                0x1_u64 => {
7604
7.62k
                                                    let mut v1018 = C::uextend_maybe_etor_returns::default();
7605
7.62k
                                                    C::uextend_maybe_etor(ctx, v271.0, &mut v1018);
7606
7.62k
                                                    let mut v1018 = v1018.into_context_iter();
7607
15.2k
                                                    while let Some(
v10197.63k
) = v1018.next(ctx) {
7608
7.63k
                                                        let mut v1022 = C::inst_data_value_etor_returns::default();
7609
7.63k
                                                        C::inst_data_value_etor(ctx, v1019.1, &mut v1022);
7610
7.63k
                                                        let mut v1022 = v1022.into_context_iter();
7611
14.4k
                                                        while let Some(
v10236.85k
) = v1022.next(ctx) {
7612
                                                            if let &InstructionData::IntCompare {
7613
4
                                                                opcode: ref v1026,
7614
4
                                                                args: ref v1027,
7615
4
                                                                cond: ref v1028,
7616
6.85k
                                                            } = &v1023.1 {
7617
4
                                                                if let &Opcode::Icmp = v1026 {
7618
4
                                                                    let v1032 = C::subsume(ctx, v1019.1);
7619
                                                                    // Rule at src/opts/icmp.isle line 69.
7620
4
                                                                    returns.extend(Some(v1032));
7621
4
                                                                    if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
7622
0
                                                                }
7623
6.84k
                                                            }
7624
                                                        }
7625
                                                    }
7626
                                                }
7627
15.0k
                                                _ => {}
7628
                                            }
7629
0
                                        }
7630
                                    }
7631
33.5k
                                    _ => {}
7632
                                }
7633
                            }
7634
163k
                            if v271.0 == v271.1 {
7635
29
                                let v52 = C::ty_int(ctx, v2.0);
7636
29
                                if let Some(v53) = v52 {
7637
29
                                    let v996 = constructor_iconst_u(ctx, v53, 0x1_u64);
7638
29
                                    let v997 = C::subsume(ctx, v996);
7639
                                    // Rule at src/opts/icmp.isle line 4.
7640
29
                                    returns.extend(Some(v997));
7641
29
                                    if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
7642
0
                                }
7643
163k
                            }
7644
                        }
7645
                        &IntCC::NotEqual => {
7646
67.5k
                            let v271 = C::unpack_value_array_2(ctx, v269);
7647
67.5k
                            let mut v598 = C::inst_data_value_etor_returns::default();
7648
67.5k
                            C::inst_data_value_etor(ctx, v271.0, &mut v598);
7649
67.5k
                            let mut v598 = v598.into_context_iter();
7650
133k
                            while let Some(
v59966.1k
) = v598.next(ctx) {
7651
66.1k
                                match &v599.1 {
7652
                                    &InstructionData::Binary {
7653
17.4k
                                        opcode: ref v653,
7654
17.4k
                                        args: ref v654,
7655
                                    } => {
7656
17.4k
                                        match v653 {
7657
                                            &Opcode::Iadd => {
7658
11.8k
                                                let mut v274 = C::inst_data_value_etor_returns::default();
7659
11.8k
                                                C::inst_data_value_etor(ctx, v271.1, &mut v274);
7660
11.8k
                                                let mut v274 = v274.into_context_iter();
7661
23.0k
                                                while let Some(
v27511.2k
) = v274.next(ctx) {
7662
11.2k
                                                    match &v275.1 {
7663
                                                        &InstructionData::Binary {
7664
3.83k
                                                            opcode: ref v670,
7665
3.83k
                                                            args: ref v671,
7666
                                                        } => {
7667
3.83k
                                                            if let &Opcode::Iadd = v670 {
7668
3.80k
                                                                let v655 = C::unpack_value_array_2(ctx, v654);
7669
3.80k
                                                                let v672 = C::unpack_value_array_2(ctx, v671);
7670
3.80k
                                                                if v655.0 == v672.0 {
7671
2
                                                                    let v1012 = constructor_ne(ctx, v2.0, v655.1, v672.1);
7672
2
                                                                    let v1013 = C::subsume(ctx, v1012);
7673
                                                                    // Rule at src/opts/icmp.isle line 34.
7674
2
                                                                    returns.extend(Some(v1013));
7675
2
                                                                    if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
7676
3.80k
                                                                }
7677
3.80k
                                                                if v655.0 == v672.1 {
7678
0
                                                                    let v1010 = constructor_ne(ctx, v2.0, v655.1, v672.0);
7679
0
                                                                    let v1011 = C::subsume(ctx, v1010);
7680
                                                                    // Rule at src/opts/icmp.isle line 32.
7681
0
                                                                    returns.extend(Some(v1011));
7682
0
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
7683
3.80k
                                                                }
7684
3.80k
                                                                if v655.1 == v672.0 {
7685
0
                                                                    let v1008 = constructor_ne(ctx, v2.0, v655.0, v672.1);
7686
0
                                                                    let v1009 = C::subsume(ctx, v1008);
7687
                                                                    // Rule at src/opts/icmp.isle line 30.
7688
0
                                                                    returns.extend(Some(v1009));
7689
0
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
7690
3.80k
                                                                }
7691
3.80k
                                                                if v655.1 == v672.1 {
7692
39
                                                                    let v1006 = constructor_ne(ctx, v2.0, v655.0, v672.0);
7693
39
                                                                    let v1007 = C::subsume(ctx, v1006);
7694
                                                                    // Rule at src/opts/icmp.isle line 28.
7695
39
                                                                    returns.extend(Some(v1007));
7696
39
                                                                    if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
7697
3.76k
                                                                }
7698
3.80k
                                                                let mut v658 = C::inst_data_value_etor_returns::default();
7699
3.80k
                                                                C::inst_data_value_etor(ctx, v655.1, &mut v658);
7700
3.80k
                                                                let mut v658 = v658.into_context_iter();
7701
7.59k
                                                                while let Some(
v6593.79k
) = v658.next(ctx) {
7702
                                                                    if let &InstructionData::UnaryImm {
7703
3.11k
                                                                        opcode: ref v662,
7704
3.11k
                                                                        imm: v663,
7705
3.79k
                                                                    } = &v659.1 {
7706
3.11k
                                                                        if let &Opcode::Iconst = v662 {
7707
3.11k
                                                                            let mut v675 = C::inst_data_value_etor_returns::default();
7708
3.11k
                                                                            C::inst_data_value_etor(ctx, v672.1, &mut v675);
7709
3.11k
                                                                            let mut v675 = v675.into_context_iter();
7710
6.14k
                                                                            while let Some(
v6763.03k
) = v675.next(ctx) {
7711
                                                                                if let &InstructionData::UnaryImm {
7712
125
                                                                                    opcode: ref v679,
7713
125
                                                                                    imm: v680,
7714
3.03k
                                                                                } = &v676.1 {
7715
125
                                                                                    if let &Opcode::Iconst = v679 {
7716
125
                                                                                        let v681 = constructor_isub(ctx, v275.0, v672.1, v655.1);
7717
125
                                                                                        let v682 = constructor_iadd(ctx, v599.0, v672.0, v681);
7718
125
                                                                                        let v684 = constructor_ne(ctx, v2.0, v655.0, v682);
7719
                                                                                        // Rule at src/opts/cprop.isle line 186.
7720
125
                                                                                        returns.extend(Some(v684));
7721
125
                                                                                        if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
7722
0
                                                                                    }
7723
2.90k
                                                                                }
7724
                                                                            }
7725
0
                                                                        }
7726
687
                                                                    }
7727
                                                                }
7728
36
                                                            }
7729
                                                        }
7730
                                                        &InstructionData::UnaryImm {
7731
1.38k
                                                            opcode: ref v278,
7732
1.38k
                                                            imm: v279,
7733
                                                        } => {
7734
1.38k
                                                            if let &Opcode::Iconst = v278 {
7735
1.38k
                                                                let v655 = C::unpack_value_array_2(ctx, v654);
7736
1.38k
                                                                let mut v658 = C::inst_data_value_etor_returns::default();
7737
1.38k
                                                                C::inst_data_value_etor(ctx, v655.1, &mut v658);
7738
1.38k
                                                                let mut v658 = v658.into_context_iter();
7739
2.79k
                                                                while let Some(
v6591.40k
) = v658.next(ctx) {
7740
                                                                    if let &InstructionData::UnaryImm {
7741
961
                                                                        opcode: ref v662,
7742
961
                                                                        imm: v663,
7743
1.40k
                                                                    } = &v659.1 {
7744
961
                                                                        if let &Opcode::Iconst = v662 {
7745
961
                                                                            let v664 = constructor_isub(ctx, v599.0, v271.1, v655.1);
7746
961
                                                                            let v666 = constructor_ne(ctx, v2.0, v655.0, v664);
7747
                                                                            // Rule at src/opts/cprop.isle line 176.
7748
961
                                                                            returns.extend(Some(v666));
7749
961
                                                                            if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
7750
0
                                                                        }
7751
446
                                                                    }
7752
                                                                }
7753
0
                                                            }
7754
                                                        }
7755
5.98k
                                                        _ => {}
7756
                                                    }
7757
                                                }
7758
                                            }
7759
                                            &Opcode::Isub => {
7760
957
                                                let v655 = C::unpack_value_array_2(ctx, v654);
7761
957
                                                let mut v658 = C::inst_data_value_etor_returns::default();
7762
957
                                                C::inst_data_value_etor(ctx, v655.1, &mut v658);
7763
957
                                                let mut v658 = v658.into_context_iter();
7764
2.03k
                                                while let Some(
v6591.07k
) = v658.next(ctx) {
7765
1.07k
                                                    match &v659.1 {
7766
                                                        &InstructionData::IntCompare {
7767
0
                                                            opcode: ref v1360,
7768
0
                                                            args: ref v1361,
7769
0
                                                            cond: ref v1362,
7770
                                                        } => {
7771
0
                                                            if let &Opcode::Icmp = v1360 {
7772
0
                                                                match v1362 {
7773
                                                                    &IntCC::SignedLessThan => {
7774
0
                                                                        if v599.0 == I8 {
7775
0
                                                                            let mut v953 = C::inst_data_value_tupled_etor_returns::default();
7776
0
                                                                            C::inst_data_value_tupled_etor(ctx, v271.1, &mut v953);
7777
0
                                                                            let mut v953 = v953.into_context_iter();
7778
0
                                                                            while let Some(v954) = v953.next(ctx) {
7779
0
                                                                                let v955 = C::iconst_sextend_etor(ctx, v954);
7780
0
                                                                                if let Some(v956) = v955 {
7781
0
                                                                                    match v956.1 {
7782
                                                                                        -1_i64 => {
7783
0
                                                                                            let mut v1350 = C::inst_data_value_etor_returns::default();
7784
0
                                                                                            C::inst_data_value_etor(ctx, v655.0, &mut v1350);
7785
0
                                                                                            let mut v1350 = v1350.into_context_iter();
7786
0
                                                                                            while let Some(v1351) = v1350.next(ctx) {
7787
                                                                                                if let &InstructionData::IntCompare {
7788
0
                                                                                                    opcode: ref v1354,
7789
0
                                                                                                    args: ref v1355,
7790
0
                                                                                                    cond: ref v1356,
7791
0
                                                                                                } = &v1351.1 {
7792
0
                                                                                                    if let &Opcode::Icmp = v1354 {
7793
0
                                                                                                        if let &IntCC::SignedGreaterThan = v1356 {
7794
0
                                                                                                            if v659.0 == v1351.0 {
7795
0
                                                                                                                let v1357 = C::unpack_value_array_2(ctx, v1355);
7796
0
                                                                                                                let v1363 = C::unpack_value_array_2(ctx, v1361);
7797
0
                                                                                                                if v1357.0 == v1363.0 {
7798
0
                                                                                                                    if v1357.1 == v1363.1 {
7799
0
                                                                                                                        let v1374 = constructor_sge(ctx, v1351.0, v1357.0, v1357.1);
7800
                                                                                                                        // Rule at src/opts/spaceship.isle line 182.
7801
0
                                                                                                                        returns.extend(Some(v1374));
7802
0
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
7803
0
                                                                                                                    }
7804
0
                                                                                                                }
7805
0
                                                                                                            }
7806
0
                                                                                                        }
7807
0
                                                                                                    }
7808
0
                                                                                                }
7809
                                                                                            }
7810
                                                                                        }
7811
                                                                                        0_i64 => {
7812
0
                                                                                            let mut v1350 = C::inst_data_value_etor_returns::default();
7813
0
                                                                                            C::inst_data_value_etor(ctx, v655.0, &mut v1350);
7814
0
                                                                                            let mut v1350 = v1350.into_context_iter();
7815
0
                                                                                            while let Some(v1351) = v1350.next(ctx) {
7816
                                                                                                if let &InstructionData::IntCompare {
7817
0
                                                                                                    opcode: ref v1354,
7818
0
                                                                                                    args: ref v1355,
7819
0
                                                                                                    cond: ref v1356,
7820
0
                                                                                                } = &v1351.1 {
7821
0
                                                                                                    if let &Opcode::Icmp = v1354 {
7822
0
                                                                                                        if let &IntCC::SignedGreaterThan = v1356 {
7823
0
                                                                                                            if v659.0 == v1351.0 {
7824
0
                                                                                                                let v1357 = C::unpack_value_array_2(ctx, v1355);
7825
0
                                                                                                                let v1363 = C::unpack_value_array_2(ctx, v1361);
7826
0
                                                                                                                if v1357.0 == v1363.0 {
7827
0
                                                                                                                    if v1357.1 == v1363.1 {
7828
0
                                                                                                                        let v1367 = constructor_ne(ctx, v1351.0, v1357.0, v1357.1);
7829
                                                                                                                        // Rule at src/opts/spaceship.isle line 150.
7830
0
                                                                                                                        returns.extend(Some(v1367));
7831
0
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
7832
0
                                                                                                                    }
7833
0
                                                                                                                }
7834
0
                                                                                                            }
7835
0
                                                                                                        }
7836
0
                                                                                                    }
7837
0
                                                                                                }
7838
                                                                                            }
7839
                                                                                        }
7840
                                                                                        1_i64 => {
7841
0
                                                                                            let mut v1350 = C::inst_data_value_etor_returns::default();
7842
0
                                                                                            C::inst_data_value_etor(ctx, v655.0, &mut v1350);
7843
0
                                                                                            let mut v1350 = v1350.into_context_iter();
7844
0
                                                                                            while let Some(v1351) = v1350.next(ctx) {
7845
                                                                                                if let &InstructionData::IntCompare {
7846
0
                                                                                                    opcode: ref v1354,
7847
0
                                                                                                    args: ref v1355,
7848
0
                                                                                                    cond: ref v1356,
7849
0
                                                                                                } = &v1351.1 {
7850
0
                                                                                                    if let &Opcode::Icmp = v1354 {
7851
0
                                                                                                        if let &IntCC::SignedGreaterThan = v1356 {
7852
0
                                                                                                            if v659.0 == v1351.0 {
7853
0
                                                                                                                let v1357 = C::unpack_value_array_2(ctx, v1355);
7854
0
                                                                                                                let v1363 = C::unpack_value_array_2(ctx, v1361);
7855
0
                                                                                                                if v1357.0 == v1363.0 {
7856
0
                                                                                                                    if v1357.1 == v1363.1 {
7857
0
                                                                                                                        let v1370 = constructor_sle(ctx, v1351.0, v1357.0, v1357.1);
7858
                                                                                                                        // Rule at src/opts/spaceship.isle line 190.
7859
0
                                                                                                                        returns.extend(Some(v1370));
7860
0
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
7861
0
                                                                                                                    }
7862
0
                                                                                                                }
7863
0
                                                                                                            }
7864
0
                                                                                                        }
7865
0
                                                                                                    }
7866
0
                                                                                                }
7867
                                                                                            }
7868
                                                                                        }
7869
0
                                                                                        _ => {}
7870
                                                                                    }
7871
0
                                                                                }
7872
                                                                            }
7873
0
                                                                        }
7874
                                                                    }
7875
                                                                    &IntCC::UnsignedLessThan => {
7876
0
                                                                        if v599.0 == I8 {
7877
0
                                                                            let mut v953 = C::inst_data_value_tupled_etor_returns::default();
7878
0
                                                                            C::inst_data_value_tupled_etor(ctx, v271.1, &mut v953);
7879
0
                                                                            let mut v953 = v953.into_context_iter();
7880
0
                                                                            while let Some(v954) = v953.next(ctx) {
7881
0
                                                                                let v955 = C::iconst_sextend_etor(ctx, v954);
7882
0
                                                                                if let Some(v956) = v955 {
7883
0
                                                                                    match v956.1 {
7884
                                                                                        -1_i64 => {
7885
0
                                                                                            let mut v1350 = C::inst_data_value_etor_returns::default();
7886
0
                                                                                            C::inst_data_value_etor(ctx, v655.0, &mut v1350);
7887
0
                                                                                            let mut v1350 = v1350.into_context_iter();
7888
0
                                                                                            while let Some(v1351) = v1350.next(ctx) {
7889
                                                                                                if let &InstructionData::IntCompare {
7890
0
                                                                                                    opcode: ref v1354,
7891
0
                                                                                                    args: ref v1355,
7892
0
                                                                                                    cond: ref v1356,
7893
0
                                                                                                } = &v1351.1 {
7894
0
                                                                                                    if let &Opcode::Icmp = v1354 {
7895
0
                                                                                                        if let &IntCC::UnsignedGreaterThan = v1356 {
7896
0
                                                                                                            if v659.0 == v1351.0 {
7897
0
                                                                                                                let v1357 = C::unpack_value_array_2(ctx, v1355);
7898
0
                                                                                                                let v1363 = C::unpack_value_array_2(ctx, v1361);
7899
0
                                                                                                                if v1357.0 == v1363.0 {
7900
0
                                                                                                                    if v1357.1 == v1363.1 {
7901
0
                                                                                                                        let v1375 = constructor_uge(ctx, v1351.0, v1357.0, v1357.1);
7902
                                                                                                                        // Rule at src/opts/spaceship.isle line 184.
7903
0
                                                                                                                        returns.extend(Some(v1375));
7904
0
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
7905
0
                                                                                                                    }
7906
0
                                                                                                                }
7907
0
                                                                                                            }
7908
0
                                                                                                        }
7909
0
                                                                                                    }
7910
0
                                                                                                }
7911
                                                                                            }
7912
                                                                                        }
7913
                                                                                        0_i64 => {
7914
0
                                                                                            let mut v1350 = C::inst_data_value_etor_returns::default();
7915
0
                                                                                            C::inst_data_value_etor(ctx, v655.0, &mut v1350);
7916
0
                                                                                            let mut v1350 = v1350.into_context_iter();
7917
0
                                                                                            while let Some(v1351) = v1350.next(ctx) {
7918
                                                                                                if let &InstructionData::IntCompare {
7919
0
                                                                                                    opcode: ref v1354,
7920
0
                                                                                                    args: ref v1355,
7921
0
                                                                                                    cond: ref v1356,
7922
0
                                                                                                } = &v1351.1 {
7923
0
                                                                                                    if let &Opcode::Icmp = v1354 {
7924
0
                                                                                                        if let &IntCC::UnsignedGreaterThan = v1356 {
7925
0
                                                                                                            if v659.0 == v1351.0 {
7926
0
                                                                                                                let v1357 = C::unpack_value_array_2(ctx, v1355);
7927
0
                                                                                                                let v1363 = C::unpack_value_array_2(ctx, v1361);
7928
0
                                                                                                                if v1357.0 == v1363.0 {
7929
0
                                                                                                                    if v1357.1 == v1363.1 {
7930
0
                                                                                                                        let v1367 = constructor_ne(ctx, v1351.0, v1357.0, v1357.1);
7931
                                                                                                                        // Rule at src/opts/spaceship.isle line 152.
7932
0
                                                                                                                        returns.extend(Some(v1367));
7933
0
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
7934
0
                                                                                                                    }
7935
0
                                                                                                                }
7936
0
                                                                                                            }
7937
0
                                                                                                        }
7938
0
                                                                                                    }
7939
0
                                                                                                }
7940
                                                                                            }
7941
                                                                                        }
7942
                                                                                        1_i64 => {
7943
0
                                                                                            let mut v1350 = C::inst_data_value_etor_returns::default();
7944
0
                                                                                            C::inst_data_value_etor(ctx, v655.0, &mut v1350);
7945
0
                                                                                            let mut v1350 = v1350.into_context_iter();
7946
0
                                                                                            while let Some(v1351) = v1350.next(ctx) {
7947
                                                                                                if let &InstructionData::IntCompare {
7948
0
                                                                                                    opcode: ref v1354,
7949
0
                                                                                                    args: ref v1355,
7950
0
                                                                                                    cond: ref v1356,
7951
0
                                                                                                } = &v1351.1 {
7952
0
                                                                                                    if let &Opcode::Icmp = v1354 {
7953
0
                                                                                                        if let &IntCC::UnsignedGreaterThan = v1356 {
7954
0
                                                                                                            if v659.0 == v1351.0 {
7955
0
                                                                                                                let v1357 = C::unpack_value_array_2(ctx, v1355);
7956
0
                                                                                                                let v1363 = C::unpack_value_array_2(ctx, v1361);
7957
0
                                                                                                                if v1357.0 == v1363.0 {
7958
0
                                                                                                                    if v1357.1 == v1363.1 {
7959
0
                                                                                                                        let v1371 = constructor_ule(ctx, v1351.0, v1357.0, v1357.1);
7960
                                                                                                                        // Rule at src/opts/spaceship.isle line 192.
7961
0
                                                                                                                        returns.extend(Some(v1371));
7962
0
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
7963
0
                                                                                                                    }
7964
0
                                                                                                                }
7965
0
                                                                                                            }
7966
0
                                                                                                        }
7967
0
                                                                                                    }
7968
0
                                                                                                }
7969
                                                                                            }
7970
                                                                                        }
7971
0
                                                                                        _ => {}
7972
                                                                                    }
7973
0
                                                                                }
7974
                                                                            }
7975
0
                                                                        }
7976
                                                                    }
7977
0
                                                                    _ => {}
7978
                                                                }
7979
0
                                                            }
7980
                                                        }
7981
                                                        &InstructionData::UnaryImm {
7982
0
                                                            opcode: ref v662,
7983
0
                                                            imm: v663,
7984
                                                        } => {
7985
0
                                                            if let &Opcode::Iconst = v662 {
7986
0
                                                                let mut v274 = C::inst_data_value_etor_returns::default();
7987
0
                                                                C::inst_data_value_etor(ctx, v271.1, &mut v274);
7988
0
                                                                let mut v274 = v274.into_context_iter();
7989
0
                                                                while let Some(v275) = v274.next(ctx) {
7990
                                                                    if let &InstructionData::UnaryImm {
7991
0
                                                                        opcode: ref v278,
7992
0
                                                                        imm: v279,
7993
0
                                                                    } = &v275.1 {
7994
0
                                                                        if let &Opcode::Iconst = v278 {
7995
0
                                                                            let v667 = constructor_iadd(ctx, v599.0, v271.1, v655.1);
7996
0
                                                                            let v669 = constructor_ne(ctx, v2.0, v655.0, v667);
7997
                                                                            // Rule at src/opts/cprop.isle line 181.
7998
0
                                                                            returns.extend(Some(v669));
7999
0
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
8000
0
                                                                        }
8001
0
                                                                    }
8002
                                                                }
8003
0
                                                            }
8004
                                                        }
8005
1.07k
                                                        _ => {}
8006
                                                    }
8007
                                                }
8008
957
                                                let mut v274 = C::inst_data_value_etor_returns::default();
8009
957
                                                C::inst_data_value_etor(ctx, v271.1, &mut v274);
8010
957
                                                let mut v274 = v274.into_context_iter();
8011
1.95k
                                                while let Some(
v2751.00k
) = v274.next(ctx) {
8012
                                                    if let &InstructionData::Binary {
8013
481
                                                        opcode: ref v670,
8014
481
                                                        args: ref v671,
8015
1.00k
                                                    } = &v275.1 {
8016
481
                                                        if let &Opcode::Isub = v670 {
8017
55
                                                            let v672 = C::unpack_value_array_2(ctx, v671);
8018
55
                                                            let v1014 = constructor_iadd(ctx, v599.0, v655.0, v672.1);
8019
55
                                                            let v1015 = constructor_iadd(ctx, v275.0, v672.0, v655.1);
8020
55
                                                            let v1017 = constructor_ne(ctx, v2.0, v1014, v1015);
8021
                                                            // Rule at src/opts/icmp.isle line 42.
8022
55
                                                            returns.extend(Some(v1017));
8023
55
                                                            if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
8024
426
                                                        }
8025
521
                                                    }
8026
                                                }
8027
                                            }
8028
4.65k
                                            _ => {}
8029
                                        }
8030
                                    }
8031
                                    &InstructionData::Unary {
8032
512
                                        opcode: ref v945,
8033
512
                                        arg: v946,
8034
                                    } => {
8035
512
                                        if let &Opcode::Sextend = v945 {
8036
39
                                            let mut v953 = C::inst_data_value_tupled_etor_returns::default();
8037
39
                                            C::inst_data_value_tupled_etor(ctx, v271.1, &mut v953);
8038
39
                                            let mut v953 = v953.into_context_iter();
8039
78
                                            while let Some(
v95439
) = v953.next(ctx) {
8040
39
                                                let v955 = C::iconst_sextend_etor(ctx, v954);
8041
39
                                                if let Some(v956) = v955 {
8042
39
                                                    if v956.1 == 0_i64 {
8043
0
                                                        let v947 = C::value_type(ctx, v946);
8044
0
                                                        let v960 = constructor_iconst_s(ctx, v947, 0_i64);
8045
0
                                                        let v962 = constructor_ne(ctx, v947, v946, v960);
8046
                                                        // Rule at src/opts/extends.isle line 41.
8047
0
                                                        returns.extend(Some(v962));
8048
0
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
8049
39
                                                    }
8050
0
                                                }
8051
                                            }
8052
473
                                        }
8053
                                    }
8054
48.1k
                                    _ => {}
8055
                                }
8056
                            }
8057
67.5k
                            let mut v274 = C::inst_data_value_etor_returns::default();
8058
67.5k
                            C::inst_data_value_etor(ctx, v271.1, &mut v274);
8059
67.5k
                            let mut v274 = v274.into_context_iter();
8060
133k
                            while let Some(
v27565.6k
) = v274.next(ctx) {
8061
65.6k
                                match &v275.1 {
8062
                                    &InstructionData::Binary {
8063
8.42k
                                        opcode: ref v670,
8064
8.42k
                                        args: ref v671,
8065
                                    } => {
8066
8.42k
                                        if let &Opcode::Bxor = v670 {
8067
0
                                            let v1135 = C::ty_int(ctx, v275.0);
8068
0
                                            if let Some(v1136) = v1135 {
8069
0
                                                let v672 = C::unpack_value_array_2(ctx, v671);
8070
0
                                                if v271.0 == v672.0 {
8071
0
                                                    let v1137 = constructor_iconst_u(ctx, v1136, 0x0_u64);
8072
0
                                                    let v1140 = constructor_ne(ctx, v2.0, v672.1, v1137);
8073
0
                                                    let v1141 = C::subsume(ctx, v1140);
8074
                                                    // Rule at src/opts/icmp.isle line 291.
8075
0
                                                    returns.extend(Some(v1141));
8076
0
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
8077
0
                                                }
8078
0
                                            }
8079
8.42k
                                        }
8080
                                    }
8081
                                    &InstructionData::UnaryImm {
8082
30.5k
                                        opcode: ref v278,
8083
30.5k
                                        imm: v279,
8084
                                    } => {
8085
30.5k
                                        if let &Opcode::Iconst = v278 {
8086
30.5k
                                            let v280 = C::u64_from_imm64(ctx, v279);
8087
30.5k
                                            match v280 {
8088
                                                0x0_u64 => {
8089
4.30k
                                                    let mut v281 = ContextIterWrapper::<ConstructorVec<_>, _>::default();
8090
4.30k
                                                    constructor_truthy(ctx, v271.0, &mut v281);
8091
4.30k
                                                    let mut v281 = v281.into_context_iter();
8092
4.31k
                                                    while let Some(
v2822
) = v281.next(ctx) {
8093
2
                                                        let v283 = C::value_type(ctx, v282);
8094
2
                                                        let v284 = C::ty_int_ref_scalar_64_extract(ctx, v283);
8095
2
                                                        if let Some(v285) = v284 {
8096
2
                                                            let v286 = constructor_iconst_u(ctx, v285, 0x0_u64);
8097
2
                                                            let v287 = constructor_ne(ctx, v2.0, v282, v286);
8098
                                                            // Rule at src/opts/bitops.isle line 122.
8099
2
                                                            returns.extend(Some(v287));
8100
2
                                                            if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
8101
0
                                                        }
8102
                                                    }
8103
4.30k
                                                    let mut v1018 = C::uextend_maybe_etor_returns::default();
8104
4.30k
                                                    C::uextend_maybe_etor(ctx, v271.0, &mut v1018);
8105
4.30k
                                                    let mut v1018 = v1018.into_context_iter();
8106
8.61k
                                                    while let Some(
v10194.30k
) = v1018.next(ctx) {
8107
4.30k
                                                        let mut v1022 = C::inst_data_value_etor_returns::default();
8108
4.30k
                                                        C::inst_data_value_etor(ctx, v1019.1, &mut v1022);
8109
4.30k
                                                        let mut v1022 = v1022.into_context_iter();
8110
8.46k
                                                        while let Some(
v10234.15k
) = v1022.next(ctx) {
8111
                                                            if let &InstructionData::IntCompare {
8112
0
                                                                opcode: ref v1026,
8113
0
                                                                args: ref v1027,
8114
0
                                                                cond: ref v1028,
8115
4.15k
                                                            } = &v1023.1 {
8116
0
                                                                if let &Opcode::Icmp = v1026 {
8117
0
                                                                    if v2.0 == v1023.0 {
8118
0
                                                                        let v1032 = C::subsume(ctx, v1019.1);
8119
                                                                        // Rule at src/opts/icmp.isle line 48.
8120
0
                                                                        returns.extend(Some(v1032));
8121
0
                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
8122
0
                                                                    }
8123
0
                                                                }
8124
4.15k
                                                            }
8125
                                                        }
8126
                                                    }
8127
                                                }
8128
                                                0x1_u64 => {
8129
15.4k
                                                    let mut v1018 = C::uextend_maybe_etor_returns::default();
8130
15.4k
                                                    C::uextend_maybe_etor(ctx, v271.0, &mut v1018);
8131
15.4k
                                                    let mut v1018 = v1018.into_context_iter();
8132
31.0k
                                                    while let Some(
v101915.5k
) = v1018.next(ctx) {
8133
15.5k
                                                        let mut v1022 = C::inst_data_value_etor_returns::default();
8134
15.5k
                                                        C::inst_data_value_etor(ctx, v1019.1, &mut v1022);
8135
15.5k
                                                        let mut v1022 = v1022.into_context_iter();
8136
30.8k
                                                        while let Some(
v102315.3k
) = v1022.next(ctx) {
8137
                                                            if let &InstructionData::IntCompare {
8138
22
                                                                opcode: ref v1026,
8139
22
                                                                args: ref v1027,
8140
22
                                                                cond: ref v1028,
8141
15.3k
                                                            } = &v1023.1 {
8142
22
                                                                if let &Opcode::Icmp = v1026 {
8143
22
                                                                    if v2.0 == v1023.0 {
8144
22
                                                                        let v1033 = &C::intcc_complement(ctx, v1028);
8145
22
                                                                        let v1029 = C::unpack_value_array_2(ctx, v1027);
8146
22
                                                                        let v1034 = constructor_icmp(ctx, v2.0, v1033, v1029.0, v1029.1);
8147
22
                                                                        let v1035 = C::subsume(ctx, v1034);
8148
                                                                        // Rule at src/opts/icmp.isle line 62.
8149
22
                                                                        returns.extend(Some(v1035));
8150
22
                                                                        if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
8151
0
                                                                    }
8152
0
                                                                }
8153
15.3k
                                                            }
8154
                                                        }
8155
                                                    }
8156
                                                }
8157
10.7k
                                                _ => {}
8158
                                            }
8159
0
                                        }
8160
                                    }
8161
26.6k
                                    _ => {}
8162
                                }
8163
                            }
8164
67.5k
                            if v271.0 == v271.1 {
8165
2
                                let v52 = C::ty_int(ctx, v2.0);
8166
2
                                if let Some(v53) = v52 {
8167
2
                                    let v55 = constructor_iconst_u(ctx, v53, 0x0_u64);
8168
2
                                    let v56 = C::subsume(ctx, v55);
8169
                                    // Rule at src/opts/icmp.isle line 5.
8170
2
                                    returns.extend(Some(v56));
8171
2
                                    if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
8172
0
                                }
8173
67.5k
                            }
8174
                        }
8175
                        &IntCC::SignedGreaterThan => {
8176
1.00k
                            let v271 = C::unpack_value_array_2(ctx, v269);
8177
1.00k
                            let mut v953 = C::inst_data_value_tupled_etor_returns::default();
8178
1.00k
                            C::inst_data_value_tupled_etor(ctx, v271.1, &mut v953);
8179
1.00k
                            let mut v953 = v953.into_context_iter();
8180
2.00k
                            while let Some(
v9541.00k
) = v953.next(ctx) {
8181
1.00k
                                let v955 = C::iconst_sextend_etor(ctx, v954);
8182
1.00k
                                if let Some(
v956940
) = v955 {
8183
940
                                    match v956.1 {
8184
                                        -1_i64 => {
8185
340
                                            let v1094 = constructor_iconst_s(ctx, v956.0, 0_i64);
8186
340
                                            let v1097 = constructor_sge(ctx, v2.0, v271.0, v1094);
8187
                                            // Rule at src/opts/icmp.isle line 197.
8188
340
                                            returns.extend(Some(v1097));
8189
340
                                            if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
8190
                                        }
8191
                                        0_i64 => {
8192
304
                                            let mut v598 = C::inst_data_value_etor_returns::default();
8193
304
                                            C::inst_data_value_etor(ctx, v271.0, &mut v598);
8194
304
                                            let mut v598 = v598.into_context_iter();
8195
608
                                            while let Some(
v599304
) = v598.next(ctx) {
8196
304
                                                if v599.0 == I8 {
8197
                                                    if let &InstructionData::Binary {
8198
0
                                                        opcode: ref v653,
8199
0
                                                        args: ref v654,
8200
0
                                                    } = &v599.1 {
8201
0
                                                        if let &Opcode::Isub = v653 {
8202
0
                                                            let v655 = C::unpack_value_array_2(ctx, v654);
8203
0
                                                            let mut v658 = C::inst_data_value_etor_returns::default();
8204
0
                                                            C::inst_data_value_etor(ctx, v655.1, &mut v658);
8205
0
                                                            let mut v658 = v658.into_context_iter();
8206
0
                                                            while let Some(v659) = v658.next(ctx) {
8207
                                                                if let &InstructionData::IntCompare {
8208
0
                                                                    opcode: ref v1360,
8209
0
                                                                    args: ref v1361,
8210
0
                                                                    cond: ref v1362,
8211
0
                                                                } = &v659.1 {
8212
0
                                                                    if let &Opcode::Icmp = v1360 {
8213
0
                                                                        match v1362 {
8214
                                                                            &IntCC::SignedLessThan => {
8215
0
                                                                                let mut v1350 = C::inst_data_value_etor_returns::default();
8216
0
                                                                                C::inst_data_value_etor(ctx, v655.0, &mut v1350);
8217
0
                                                                                let mut v1350 = v1350.into_context_iter();
8218
0
                                                                                while let Some(v1351) = v1350.next(ctx) {
8219
                                                                                    if let &InstructionData::IntCompare {
8220
0
                                                                                        opcode: ref v1354,
8221
0
                                                                                        args: ref v1355,
8222
0
                                                                                        cond: ref v1356,
8223
0
                                                                                    } = &v1351.1 {
8224
0
                                                                                        if let &Opcode::Icmp = v1354 {
8225
0
                                                                                            if let &IntCC::SignedGreaterThan = v1356 {
8226
0
                                                                                                if v659.0 == v1351.0 {
8227
0
                                                                                                    let v1357 = C::unpack_value_array_2(ctx, v1355);
8228
0
                                                                                                    let v1363 = C::unpack_value_array_2(ctx, v1361);
8229
0
                                                                                                    if v1357.0 == v1363.0 {
8230
0
                                                                                                        if v1357.1 == v1363.1 {
8231
0
                                                                                                            let v1372 = constructor_sgt(ctx, v1351.0, v1357.0, v1357.1);
8232
                                                                                                            // Rule at src/opts/spaceship.isle line 166.
8233
0
                                                                                                            returns.extend(Some(v1372));
8234
0
                                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
8235
0
                                                                                                        }
8236
0
                                                                                                    }
8237
0
                                                                                                }
8238
0
                                                                                            }
8239
0
                                                                                        }
8240
0
                                                                                    }
8241
                                                                                }
8242
                                                                            }
8243
                                                                            &IntCC::UnsignedLessThan => {
8244
0
                                                                                let mut v1350 = C::inst_data_value_etor_returns::default();
8245
0
                                                                                C::inst_data_value_etor(ctx, v655.0, &mut v1350);
8246
0
                                                                                let mut v1350 = v1350.into_context_iter();
8247
0
                                                                                while let Some(v1351) = v1350.next(ctx) {
8248
                                                                                    if let &InstructionData::IntCompare {
8249
0
                                                                                        opcode: ref v1354,
8250
0
                                                                                        args: ref v1355,
8251
0
                                                                                        cond: ref v1356,
8252
0
                                                                                    } = &v1351.1 {
8253
0
                                                                                        if let &Opcode::Icmp = v1354 {
8254
0
                                                                                            if let &IntCC::UnsignedGreaterThan = v1356 {
8255
0
                                                                                                if v659.0 == v1351.0 {
8256
0
                                                                                                    let v1357 = C::unpack_value_array_2(ctx, v1355);
8257
0
                                                                                                    let v1363 = C::unpack_value_array_2(ctx, v1361);
8258
0
                                                                                                    if v1357.0 == v1363.0 {
8259
0
                                                                                                        if v1357.1 == v1363.1 {
8260
0
                                                                                                            let v1373 = constructor_ugt(ctx, v1351.0, v1357.0, v1357.1);
8261
                                                                                                            // Rule at src/opts/spaceship.isle line 168.
8262
0
                                                                                                            returns.extend(Some(v1373));
8263
0
                                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
8264
0
                                                                                                        }
8265
0
                                                                                                    }
8266
0
                                                                                                }
8267
0
                                                                                            }
8268
0
                                                                                        }
8269
0
                                                                                    }
8270
                                                                                }
8271
                                                                            }
8272
0
                                                                            _ => {}
8273
                                                                        }
8274
0
                                                                    }
8275
0
                                                                }
8276
                                                            }
8277
0
                                                        }
8278
0
                                                    }
8279
304
                                                }
8280
                                            }
8281
                                        }
8282
296
                                        _ => {}
8283
                                    }
8284
64
                                }
8285
                            }
8286
1.00k
                            let v541 = C::fits_in_64(ctx, v2.0);
8287
1.00k
                            if let Some(v542) = v541 {
8288
1.00k
                                let v1063 = C::ty_int(ctx, v542);
8289
1.00k
                                if let Some(v1064) = v1063 {
8290
1.00k
                                    let mut v274 = C::inst_data_value_etor_returns::default();
8291
1.00k
                                    C::inst_data_value_etor(ctx, v271.1, &mut v274);
8292
1.00k
                                    let mut v274 = v274.into_context_iter();
8293
2.00k
                                    while let Some(
v2751.00k
) = v274.next(ctx) {
8294
                                        if let &InstructionData::UnaryImm {
8295
940
                                            opcode: ref v278,
8296
940
                                            imm: v279,
8297
1.00k
                                        } = &v275.1 {
8298
940
                                            if let &Opcode::Iconst = v278 {
8299
940
                                                let v280 = C::u64_from_imm64(ctx, v279);
8300
940
                                                let v1073 = C::ty_smin(ctx, v275.0);
8301
940
                                                let v1074 = C::u64_eq(ctx, v280, v1073);
8302
940
                                                if v1074 == true {
8303
0
                                                    let v1068 = constructor_ne(ctx, v1064, v271.0, v271.1);
8304
                                                    // Rule at src/opts/icmp.isle line 145.
8305
0
                                                    returns.extend(Some(v1068));
8306
0
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
8307
940
                                                }
8308
940
                                                let v1075 = C::ty_smax(ctx, v275.0);
8309
940
                                                let v1076 = C::u64_eq(ctx, v280, v1075);
8310
940
                                                if v1076 == true {
8311
0
                                                    let v1065 = constructor_iconst_u(ctx, v1064, 0x0_u64);
8312
0
                                                    let v1066 = C::subsume(ctx, v1065);
8313
                                                    // Rule at src/opts/icmp.isle line 165.
8314
0
                                                    returns.extend(Some(v1066));
8315
0
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
8316
940
                                                }
8317
0
                                            }
8318
64
                                        }
8319
                                    }
8320
0
                                }
8321
0
                            }
8322
1.00k
                            let v52 = C::ty_int(ctx, v2.0);
8323
1.00k
                            if let Some(v53) = v52 {
8324
1.00k
                                if v271.0 == v271.1 {
8325
0
                                    let v55 = constructor_iconst_u(ctx, v53, 0x0_u64);
8326
0
                                    let v56 = C::subsume(ctx, v55);
8327
                                    // Rule at src/opts/icmp.isle line 8.
8328
0
                                    returns.extend(Some(v56));
8329
0
                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
8330
1.00k
                                }
8331
0
                            }
8332
                        }
8333
                        &IntCC::SignedGreaterThanOrEqual => {
8334
621
                            let v271 = C::unpack_value_array_2(ctx, v269);
8335
621
                            let mut v274 = C::inst_data_value_etor_returns::default();
8336
621
                            C::inst_data_value_etor(ctx, v271.1, &mut v274);
8337
621
                            let mut v274 = v274.into_context_iter();
8338
1.24k
                            while let Some(
v275621
) = v274.next(ctx) {
8339
                                if let &InstructionData::UnaryImm {
8340
617
                                    opcode: ref v278,
8341
617
                                    imm: v279,
8342
621
                                } = &v275.1 {
8343
617
                                    if let &Opcode::Iconst = v278 {
8344
617
                                        let v541 = C::fits_in_64(ctx, v2.0);
8345
617
                                        if let Some(v542) = v541 {
8346
617
                                            let v1063 = C::ty_int(ctx, v542);
8347
617
                                            if let Some(v1064) = v1063 {
8348
617
                                                let v280 = C::u64_from_imm64(ctx, v279);
8349
617
                                                let v1073 = C::ty_smin(ctx, v275.0);
8350
617
                                                let v1074 = C::u64_eq(ctx, v280, v1073);
8351
617
                                                if v1074 == true {
8352
0
                                                    let v1069 = constructor_iconst_u(ctx, v1064, 0x1_u64);
8353
0
                                                    let v1070 = C::subsume(ctx, v1069);
8354
                                                    // Rule at src/opts/icmp.isle line 150.
8355
0
                                                    returns.extend(Some(v1070));
8356
0
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
8357
617
                                                }
8358
617
                                                let v1075 = C::ty_smax(ctx, v275.0);
8359
617
                                                let v1076 = C::u64_eq(ctx, v280, v1075);
8360
617
                                                if v1076 == true {
8361
0
                                                    let v1067 = constructor_eq(ctx, v1064, v271.0, v271.1);
8362
                                                    // Rule at src/opts/icmp.isle line 170.
8363
0
                                                    returns.extend(Some(v1067));
8364
0
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
8365
617
                                                }
8366
0
                                            }
8367
0
                                        }
8368
617
                                        let v280 = C::u64_from_imm64(ctx, v279);
8369
617
                                        if v280 == 0x0_u64 {
8370
458
                                            let mut v598 = C::inst_data_value_etor_returns::default();
8371
458
                                            C::inst_data_value_etor(ctx, v271.0, &mut v598);
8372
458
                                            let mut v598 = v598.into_context_iter();
8373
892
                                            while let Some(
v599434
) = v598.next(ctx) {
8374
434
                                                if v599.0 == I64 {
8375
                                                    if let &InstructionData::Unary {
8376
0
                                                        opcode: ref v945,
8377
0
                                                        arg: v946,
8378
0
                                                    } = &v599.1 {
8379
0
                                                        if let &Opcode::Uextend = v945 {
8380
0
                                                            let v947 = C::value_type(ctx, v946);
8381
0
                                                            if v947 == I32 {
8382
0
                                                                let v951 = constructor_iconst_u(ctx, v2.0, 0x1_u64);
8383
0
                                                                let v952 = C::subsume(ctx, v951);
8384
                                                                // Rule at src/opts/extends.isle line 32.
8385
0
                                                                returns.extend(Some(v952));
8386
0
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
8387
0
                                                            }
8388
0
                                                        }
8389
0
                                                    }
8390
434
                                                }
8391
                                            }
8392
159
                                        }
8393
0
                                    }
8394
4
                                }
8395
                            }
8396
621
                            let mut v953 = C::inst_data_value_tupled_etor_returns::default();
8397
621
                            C::inst_data_value_tupled_etor(ctx, v271.1, &mut v953);
8398
621
                            let mut v953 = v953.into_context_iter();
8399
1.24k
                            while let Some(
v954621
) = v953.next(ctx) {
8400
621
                                let v955 = C::iconst_sextend_etor(ctx, v954);
8401
621
                                if let Some(
v956617
) = v955 {
8402
617
                                    match v956.1 {
8403
                                        0_i64 => {
8404
458
                                            let mut v598 = C::inst_data_value_etor_returns::default();
8405
458
                                            C::inst_data_value_etor(ctx, v271.0, &mut v598);
8406
458
                                            let mut v598 = v598.into_context_iter();
8407
892
                                            while let Some(
v599434
) = v598.next(ctx) {
8408
434
                                                if v599.0 == I8 {
8409
                                                    if let &InstructionData::Binary {
8410
0
                                                        opcode: ref v653,
8411
0
                                                        args: ref v654,
8412
1
                                                    } = &v599.1 {
8413
0
                                                        if let &Opcode::Isub = v653 {
8414
0
                                                            let v655 = C::unpack_value_array_2(ctx, v654);
8415
0
                                                            let mut v658 = C::inst_data_value_etor_returns::default();
8416
0
                                                            C::inst_data_value_etor(ctx, v655.1, &mut v658);
8417
0
                                                            let mut v658 = v658.into_context_iter();
8418
0
                                                            while let Some(v659) = v658.next(ctx) {
8419
                                                                if let &InstructionData::IntCompare {
8420
0
                                                                    opcode: ref v1360,
8421
0
                                                                    args: ref v1361,
8422
0
                                                                    cond: ref v1362,
8423
0
                                                                } = &v659.1 {
8424
0
                                                                    if let &Opcode::Icmp = v1360 {
8425
0
                                                                        match v1362 {
8426
                                                                            &IntCC::SignedLessThan => {
8427
0
                                                                                let mut v1350 = C::inst_data_value_etor_returns::default();
8428
0
                                                                                C::inst_data_value_etor(ctx, v655.0, &mut v1350);
8429
0
                                                                                let mut v1350 = v1350.into_context_iter();
8430
0
                                                                                while let Some(v1351) = v1350.next(ctx) {
8431
                                                                                    if let &InstructionData::IntCompare {
8432
0
                                                                                        opcode: ref v1354,
8433
0
                                                                                        args: ref v1355,
8434
0
                                                                                        cond: ref v1356,
8435
0
                                                                                    } = &v1351.1 {
8436
0
                                                                                        if let &Opcode::Icmp = v1354 {
8437
0
                                                                                            if let &IntCC::SignedGreaterThan = v1356 {
8438
0
                                                                                                if v659.0 == v1351.0 {
8439
0
                                                                                                    let v1357 = C::unpack_value_array_2(ctx, v1355);
8440
0
                                                                                                    let v1363 = C::unpack_value_array_2(ctx, v1361);
8441
0
                                                                                                    if v1357.0 == v1363.0 {
8442
0
                                                                                                        if v1357.1 == v1363.1 {
8443
0
                                                                                                            let v1374 = constructor_sge(ctx, v1351.0, v1357.0, v1357.1);
8444
                                                                                                            // Rule at src/opts/spaceship.isle line 171.
8445
0
                                                                                                            returns.extend(Some(v1374));
8446
0
                                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
8447
0
                                                                                                        }
8448
0
                                                                                                    }
8449
0
                                                                                                }
8450
0
                                                                                            }
8451
0
                                                                                        }
8452
0
                                                                                    }
8453
                                                                                }
8454
                                                                            }
8455
                                                                            &IntCC::UnsignedLessThan => {
8456
0
                                                                                let mut v1350 = C::inst_data_value_etor_returns::default();
8457
0
                                                                                C::inst_data_value_etor(ctx, v655.0, &mut v1350);
8458
0
                                                                                let mut v1350 = v1350.into_context_iter();
8459
0
                                                                                while let Some(v1351) = v1350.next(ctx) {
8460
                                                                                    if let &InstructionData::IntCompare {
8461
0
                                                                                        opcode: ref v1354,
8462
0
                                                                                        args: ref v1355,
8463
0
                                                                                        cond: ref v1356,
8464
0
                                                                                    } = &v1351.1 {
8465
0
                                                                                        if let &Opcode::Icmp = v1354 {
8466
0
                                                                                            if let &IntCC::UnsignedGreaterThan = v1356 {
8467
0
                                                                                                if v659.0 == v1351.0 {
8468
0
                                                                                                    let v1357 = C::unpack_value_array_2(ctx, v1355);
8469
0
                                                                                                    let v1363 = C::unpack_value_array_2(ctx, v1361);
8470
0
                                                                                                    if v1357.0 == v1363.0 {
8471
0
                                                                                                        if v1357.1 == v1363.1 {
8472
0
                                                                                                            let v1375 = constructor_uge(ctx, v1351.0, v1357.0, v1357.1);
8473
                                                                                                            // Rule at src/opts/spaceship.isle line 173.
8474
0
                                                                                                            returns.extend(Some(v1375));
8475
0
                                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
8476
0
                                                                                                        }
8477
0
                                                                                                    }
8478
0
                                                                                                }
8479
0
                                                                                            }
8480
0
                                                                                        }
8481
0
                                                                                    }
8482
                                                                                }
8483
                                                                            }
8484
0
                                                                            _ => {}
8485
                                                                        }
8486
0
                                                                    }
8487
0
                                                                }
8488
                                                            }
8489
0
                                                        }
8490
1
                                                    }
8491
433
                                                }
8492
                                            }
8493
                                        }
8494
                                        1_i64 => {
8495
158
                                            let v1094 = constructor_iconst_s(ctx, v956.0, 0_i64);
8496
158
                                            let v1095 = constructor_sgt(ctx, v2.0, v271.0, v1094);
8497
                                            // Rule at src/opts/icmp.isle line 191.
8498
158
                                            returns.extend(Some(v1095));
8499
158
                                            if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
8500
                                        }
8501
1
                                        _ => {}
8502
                                    }
8503
4
                                }
8504
                            }
8505
621
                            let v52 = C::ty_int(ctx, v2.0);
8506
621
                            if let Some(v53) = v52 {
8507
621
                                if v271.0 == v271.1 {
8508
0
                                    let v996 = constructor_iconst_u(ctx, v53, 0x1_u64);
8509
0
                                    let v997 = C::subsume(ctx, v996);
8510
                                    // Rule at src/opts/icmp.isle line 9.
8511
0
                                    returns.extend(Some(v997));
8512
0
                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
8513
621
                                }
8514
0
                            }
8515
                        }
8516
                        &IntCC::SignedLessThan => {
8517
6.10k
                            let v271 = C::unpack_value_array_2(ctx, v269);
8518
6.10k
                            let mut v274 = C::inst_data_value_etor_returns::default();
8519
6.10k
                            C::inst_data_value_etor(ctx, v271.1, &mut v274);
8520
6.10k
                            let mut v274 = v274.into_context_iter();
8521
12.1k
                            while let Some(
v2756.09k
) = v274.next(ctx) {
8522
                                if let &InstructionData::UnaryImm {
8523
6.07k
                                    opcode: ref v278,
8524
6.07k
                                    imm: v279,
8525
6.09k
                                } = &v275.1 {
8526
6.07k
                                    if let &Opcode::Iconst = v278 {
8527
6.07k
                                        let v541 = C::fits_in_64(ctx, v2.0);
8528
6.07k
                                        if let Some(v542) = v541 {
8529
6.07k
                                            let v1063 = C::ty_int(ctx, v542);
8530
6.07k
                                            if let Some(v1064) = v1063 {
8531
6.07k
                                                let v280 = C::u64_from_imm64(ctx, v279);
8532
6.07k
                                                let v1073 = C::ty_smin(ctx, v275.0);
8533
6.07k
                                                let v1074 = C::u64_eq(ctx, v280, v1073);
8534
6.07k
                                                if v1074 == true {
8535
0
                                                    let v1065 = constructor_iconst_u(ctx, v1064, 0x0_u64);
8536
0
                                                    let v1066 = C::subsume(ctx, v1065);
8537
                                                    // Rule at src/opts/icmp.isle line 135.
8538
0
                                                    returns.extend(Some(v1066));
8539
0
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
8540
6.07k
                                                }
8541
6.07k
                                                let v1075 = C::ty_smax(ctx, v275.0);
8542
6.07k
                                                let v1076 = C::u64_eq(ctx, v280, v1075);
8543
6.07k
                                                if v1076 == true {
8544
0
                                                    let v1068 = constructor_ne(ctx, v1064, v271.0, v271.1);
8545
                                                    // Rule at src/opts/icmp.isle line 155.
8546
0
                                                    returns.extend(Some(v1068));
8547
0
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
8548
6.07k
                                                }
8549
0
                                            }
8550
0
                                        }
8551
6.07k
                                        let v280 = C::u64_from_imm64(ctx, v279);
8552
6.07k
                                        if v280 == 0x0_u64 {
8553
5.74k
                                            let mut v598 = C::inst_data_value_etor_returns::default();
8554
5.74k
                                            C::inst_data_value_etor(ctx, v271.0, &mut v598);
8555
5.74k
                                            let mut v598 = v598.into_context_iter();
8556
12.1k
                                            while let Some(
v5996.38k
) = v598.next(ctx) {
8557
6.38k
                                                if v599.0 == I64 {
8558
                                                    if let &InstructionData::Unary {
8559
0
                                                        opcode: ref v945,
8560
0
                                                        arg: v946,
8561
81
                                                    } = &v599.1 {
8562
0
                                                        if let &Opcode::Uextend = v945 {
8563
0
                                                            let v947 = C::value_type(ctx, v946);
8564
0
                                                            if v947 == I32 {
8565
0
                                                                let v948 = constructor_iconst_u(ctx, v2.0, 0x0_u64);
8566
0
                                                                let v949 = C::subsume(ctx, v948);
8567
                                                                // Rule at src/opts/extends.isle line 27.
8568
0
                                                                returns.extend(Some(v949));
8569
0
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
8570
0
                                                            }
8571
0
                                                        }
8572
81
                                                    }
8573
6.30k
                                                }
8574
                                            }
8575
331
                                        }
8576
0
                                    }
8577
21
                                }
8578
                            }
8579
6.10k
                            let mut v953 = C::inst_data_value_tupled_etor_returns::default();
8580
6.10k
                            C::inst_data_value_tupled_etor(ctx, v271.1, &mut v953);
8581
6.10k
                            let mut v953 = v953.into_context_iter();
8582
12.1k
                            while let Some(
v9546.09k
) = v953.next(ctx) {
8583
6.09k
                                let v955 = C::iconst_sextend_etor(ctx, v954);
8584
6.09k
                                if let Some(
v9566.07k
) = v955 {
8585
6.07k
                                    match v956.1 {
8586
                                        0_i64 => {
8587
5.74k
                                            let mut v598 = C::inst_data_value_etor_returns::default();
8588
5.74k
                                            C::inst_data_value_etor(ctx, v271.0, &mut v598);
8589
5.74k
                                            let mut v598 = v598.into_context_iter();
8590
12.1k
                                            while let Some(
v5996.38k
) = v598.next(ctx) {
8591
6.38k
                                                if v599.0 == I8 {
8592
                                                    if let &InstructionData::Binary {
8593
0
                                                        opcode: ref v653,
8594
0
                                                        args: ref v654,
8595
54
                                                    } = &v599.1 {
8596
0
                                                        if let &Opcode::Isub = v653 {
8597
0
                                                            let v655 = C::unpack_value_array_2(ctx, v654);
8598
0
                                                            let mut v658 = C::inst_data_value_etor_returns::default();
8599
0
                                                            C::inst_data_value_etor(ctx, v655.1, &mut v658);
8600
0
                                                            let mut v658 = v658.into_context_iter();
8601
0
                                                            while let Some(v659) = v658.next(ctx) {
8602
                                                                if let &InstructionData::IntCompare {
8603
0
                                                                    opcode: ref v1360,
8604
0
                                                                    args: ref v1361,
8605
0
                                                                    cond: ref v1362,
8606
0
                                                                } = &v659.1 {
8607
0
                                                                    if let &Opcode::Icmp = v1360 {
8608
0
                                                                        match v1362 {
8609
                                                                            &IntCC::SignedLessThan => {
8610
0
                                                                                let mut v1350 = C::inst_data_value_etor_returns::default();
8611
0
                                                                                C::inst_data_value_etor(ctx, v655.0, &mut v1350);
8612
0
                                                                                let mut v1350 = v1350.into_context_iter();
8613
0
                                                                                while let Some(v1351) = v1350.next(ctx) {
8614
                                                                                    if let &InstructionData::IntCompare {
8615
0
                                                                                        opcode: ref v1354,
8616
0
                                                                                        args: ref v1355,
8617
0
                                                                                        cond: ref v1356,
8618
0
                                                                                    } = &v1351.1 {
8619
0
                                                                                        if let &Opcode::Icmp = v1354 {
8620
0
                                                                                            if let &IntCC::SignedGreaterThan = v1356 {
8621
0
                                                                                                if v659.0 == v1351.0 {
8622
0
                                                                                                    let v1357 = C::unpack_value_array_2(ctx, v1355);
8623
0
                                                                                                    let v1363 = C::unpack_value_array_2(ctx, v1361);
8624
0
                                                                                                    if v1357.0 == v1363.0 {
8625
0
                                                                                                        if v1357.1 == v1363.1 {
8626
0
                                                                                                            let v1368 = constructor_slt(ctx, v1351.0, v1357.0, v1357.1);
8627
                                                                                                            // Rule at src/opts/spaceship.isle line 156.
8628
0
                                                                                                            returns.extend(Some(v1368));
8629
0
                                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
8630
0
                                                                                                        }
8631
0
                                                                                                    }
8632
0
                                                                                                }
8633
0
                                                                                            }
8634
0
                                                                                        }
8635
0
                                                                                    }
8636
                                                                                }
8637
                                                                            }
8638
                                                                            &IntCC::UnsignedLessThan => {
8639
0
                                                                                let mut v1350 = C::inst_data_value_etor_returns::default();
8640
0
                                                                                C::inst_data_value_etor(ctx, v655.0, &mut v1350);
8641
0
                                                                                let mut v1350 = v1350.into_context_iter();
8642
0
                                                                                while let Some(v1351) = v1350.next(ctx) {
8643
                                                                                    if let &InstructionData::IntCompare {
8644
0
                                                                                        opcode: ref v1354,
8645
0
                                                                                        args: ref v1355,
8646
0
                                                                                        cond: ref v1356,
8647
0
                                                                                    } = &v1351.1 {
8648
0
                                                                                        if let &Opcode::Icmp = v1354 {
8649
0
                                                                                            if let &IntCC::UnsignedGreaterThan = v1356 {
8650
0
                                                                                                if v659.0 == v1351.0 {
8651
0
                                                                                                    let v1357 = C::unpack_value_array_2(ctx, v1355);
8652
0
                                                                                                    let v1363 = C::unpack_value_array_2(ctx, v1361);
8653
0
                                                                                                    if v1357.0 == v1363.0 {
8654
0
                                                                                                        if v1357.1 == v1363.1 {
8655
0
                                                                                                            let v1369 = constructor_ult(ctx, v1351.0, v1357.0, v1357.1);
8656
                                                                                                            // Rule at src/opts/spaceship.isle line 158.
8657
0
                                                                                                            returns.extend(Some(v1369));
8658
0
                                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
8659
0
                                                                                                        }
8660
0
                                                                                                    }
8661
0
                                                                                                }
8662
0
                                                                                            }
8663
0
                                                                                        }
8664
0
                                                                                    }
8665
                                                                                }
8666
                                                                            }
8667
0
                                                                            _ => {}
8668
                                                                        }
8669
0
                                                                    }
8670
0
                                                                }
8671
                                                            }
8672
0
                                                        }
8673
54
                                                    }
8674
6.33k
                                                }
8675
                                            }
8676
                                        }
8677
                                        1_i64 => {
8678
195
                                            let v1094 = constructor_iconst_s(ctx, v956.0, 0_i64);
8679
195
                                            let v1096 = constructor_sle(ctx, v2.0, v271.0, v1094);
8680
                                            // Rule at src/opts/icmp.isle line 194.
8681
195
                                            returns.extend(Some(v1096));
8682
195
                                            if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
8683
                                        }
8684
136
                                        _ => {}
8685
                                    }
8686
21
                                }
8687
                            }
8688
6.10k
                            let v52 = C::ty_int(ctx, v2.0);
8689
6.10k
                            if let Some(v53) = v52 {
8690
6.10k
                                if v271.0 == v271.1 {
8691
0
                                    let v55 = constructor_iconst_u(ctx, v53, 0x0_u64);
8692
0
                                    let v56 = C::subsume(ctx, v55);
8693
                                    // Rule at src/opts/icmp.isle line 12.
8694
0
                                    returns.extend(Some(v56));
8695
0
                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
8696
6.10k
                                }
8697
0
                            }
8698
                        }
8699
                        &IntCC::SignedLessThanOrEqual => {
8700
914
                            let v271 = C::unpack_value_array_2(ctx, v269);
8701
914
                            let mut v953 = C::inst_data_value_tupled_etor_returns::default();
8702
914
                            C::inst_data_value_tupled_etor(ctx, v271.1, &mut v953);
8703
914
                            let mut v953 = v953.into_context_iter();
8704
1.82k
                            while let Some(
v954914
) = v953.next(ctx) {
8705
914
                                let v955 = C::iconst_sextend_etor(ctx, v954);
8706
914
                                if let Some(
v956865
) = v955 {
8707
865
                                    match v956.1 {
8708
                                        -1_i64 => {
8709
484
                                            let v1094 = constructor_iconst_s(ctx, v956.0, 0_i64);
8710
484
                                            let v1098 = constructor_slt(ctx, v2.0, v271.0, v1094);
8711
                                            // Rule at src/opts/icmp.isle line 200.
8712
484
                                            returns.extend(Some(v1098));
8713
484
                                            if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
8714
                                        }
8715
                                        0_i64 => {
8716
195
                                            let mut v598 = C::inst_data_value_etor_returns::default();
8717
195
                                            C::inst_data_value_etor(ctx, v271.0, &mut v598);
8718
195
                                            let mut v598 = v598.into_context_iter();
8719
390
                                            while let Some(
v599195
) = v598.next(ctx) {
8720
195
                                                if v599.0 == I8 {
8721
                                                    if let &InstructionData::Binary {
8722
0
                                                        opcode: ref v653,
8723
0
                                                        args: ref v654,
8724
0
                                                    } = &v599.1 {
8725
0
                                                        if let &Opcode::Isub = v653 {
8726
0
                                                            let v655 = C::unpack_value_array_2(ctx, v654);
8727
0
                                                            let mut v658 = C::inst_data_value_etor_returns::default();
8728
0
                                                            C::inst_data_value_etor(ctx, v655.1, &mut v658);
8729
0
                                                            let mut v658 = v658.into_context_iter();
8730
0
                                                            while let Some(v659) = v658.next(ctx) {
8731
                                                                if let &InstructionData::IntCompare {
8732
0
                                                                    opcode: ref v1360,
8733
0
                                                                    args: ref v1361,
8734
0
                                                                    cond: ref v1362,
8735
0
                                                                } = &v659.1 {
8736
0
                                                                    if let &Opcode::Icmp = v1360 {
8737
0
                                                                        match v1362 {
8738
                                                                            &IntCC::SignedLessThan => {
8739
0
                                                                                let mut v1350 = C::inst_data_value_etor_returns::default();
8740
0
                                                                                C::inst_data_value_etor(ctx, v655.0, &mut v1350);
8741
0
                                                                                let mut v1350 = v1350.into_context_iter();
8742
0
                                                                                while let Some(v1351) = v1350.next(ctx) {
8743
                                                                                    if let &InstructionData::IntCompare {
8744
0
                                                                                        opcode: ref v1354,
8745
0
                                                                                        args: ref v1355,
8746
0
                                                                                        cond: ref v1356,
8747
0
                                                                                    } = &v1351.1 {
8748
0
                                                                                        if let &Opcode::Icmp = v1354 {
8749
0
                                                                                            if let &IntCC::SignedGreaterThan = v1356 {
8750
0
                                                                                                if v659.0 == v1351.0 {
8751
0
                                                                                                    let v1357 = C::unpack_value_array_2(ctx, v1355);
8752
0
                                                                                                    let v1363 = C::unpack_value_array_2(ctx, v1361);
8753
0
                                                                                                    if v1357.0 == v1363.0 {
8754
0
                                                                                                        if v1357.1 == v1363.1 {
8755
0
                                                                                                            let v1370 = constructor_sle(ctx, v1351.0, v1357.0, v1357.1);
8756
                                                                                                            // Rule at src/opts/spaceship.isle line 161.
8757
0
                                                                                                            returns.extend(Some(v1370));
8758
0
                                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
8759
0
                                                                                                        }
8760
0
                                                                                                    }
8761
0
                                                                                                }
8762
0
                                                                                            }
8763
0
                                                                                        }
8764
0
                                                                                    }
8765
                                                                                }
8766
                                                                            }
8767
                                                                            &IntCC::UnsignedLessThan => {
8768
0
                                                                                let mut v1350 = C::inst_data_value_etor_returns::default();
8769
0
                                                                                C::inst_data_value_etor(ctx, v655.0, &mut v1350);
8770
0
                                                                                let mut v1350 = v1350.into_context_iter();
8771
0
                                                                                while let Some(v1351) = v1350.next(ctx) {
8772
                                                                                    if let &InstructionData::IntCompare {
8773
0
                                                                                        opcode: ref v1354,
8774
0
                                                                                        args: ref v1355,
8775
0
                                                                                        cond: ref v1356,
8776
0
                                                                                    } = &v1351.1 {
8777
0
                                                                                        if let &Opcode::Icmp = v1354 {
8778
0
                                                                                            if let &IntCC::UnsignedGreaterThan = v1356 {
8779
0
                                                                                                if v659.0 == v1351.0 {
8780
0
                                                                                                    let v1357 = C::unpack_value_array_2(ctx, v1355);
8781
0
                                                                                                    let v1363 = C::unpack_value_array_2(ctx, v1361);
8782
0
                                                                                                    if v1357.0 == v1363.0 {
8783
0
                                                                                                        if v1357.1 == v1363.1 {
8784
0
                                                                                                            let v1371 = constructor_ule(ctx, v1351.0, v1357.0, v1357.1);
8785
                                                                                                            // Rule at src/opts/spaceship.isle line 163.
8786
0
                                                                                                            returns.extend(Some(v1371));
8787
0
                                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
8788
0
                                                                                                        }
8789
0
                                                                                                    }
8790
0
                                                                                                }
8791
0
                                                                                            }
8792
0
                                                                                        }
8793
0
                                                                                    }
8794
                                                                                }
8795
                                                                            }
8796
0
                                                                            _ => {}
8797
                                                                        }
8798
0
                                                                    }
8799
0
                                                                }
8800
                                                            }
8801
0
                                                        }
8802
0
                                                    }
8803
195
                                                }
8804
                                            }
8805
                                        }
8806
186
                                        _ => {}
8807
                                    }
8808
49
                                }
8809
                            }
8810
914
                            let v541 = C::fits_in_64(ctx, v2.0);
8811
914
                            if let Some(v542) = v541 {
8812
914
                                let v1063 = C::ty_int(ctx, v542);
8813
914
                                if let Some(v1064) = v1063 {
8814
914
                                    let mut v274 = C::inst_data_value_etor_returns::default();
8815
914
                                    C::inst_data_value_etor(ctx, v271.1, &mut v274);
8816
914
                                    let mut v274 = v274.into_context_iter();
8817
1.82k
                                    while let Some(
v275914
) = v274.next(ctx) {
8818
                                        if let &InstructionData::UnaryImm {
8819
865
                                            opcode: ref v278,
8820
865
                                            imm: v279,
8821
914
                                        } = &v275.1 {
8822
865
                                            if let &Opcode::Iconst = v278 {
8823
865
                                                let v280 = C::u64_from_imm64(ctx, v279);
8824
865
                                                let v1073 = C::ty_smin(ctx, v275.0);
8825
865
                                                let v1074 = C::u64_eq(ctx, v280, v1073);
8826
865
                                                if v1074 == true {
8827
0
                                                    let v1067 = constructor_eq(ctx, v1064, v271.0, v271.1);
8828
                                                    // Rule at src/opts/icmp.isle line 140.
8829
0
                                                    returns.extend(Some(v1067));
8830
0
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
8831
865
                                                }
8832
865
                                                let v1075 = C::ty_smax(ctx, v275.0);
8833
865
                                                let v1076 = C::u64_eq(ctx, v280, v1075);
8834
865
                                                if v1076 == true {
8835
0
                                                    let v1069 = constructor_iconst_u(ctx, v1064, 0x1_u64);
8836
0
                                                    let v1070 = C::subsume(ctx, v1069);
8837
                                                    // Rule at src/opts/icmp.isle line 160.
8838
0
                                                    returns.extend(Some(v1070));
8839
0
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
8840
865
                                                }
8841
0
                                            }
8842
49
                                        }
8843
                                    }
8844
0
                                }
8845
0
                            }
8846
914
                            let v52 = C::ty_int(ctx, v2.0);
8847
914
                            if let Some(v53) = v52 {
8848
914
                                if v271.0 == v271.1 {
8849
0
                                    let v996 = constructor_iconst_u(ctx, v53, 0x1_u64);
8850
0
                                    let v997 = C::subsume(ctx, v996);
8851
                                    // Rule at src/opts/icmp.isle line 13.
8852
0
                                    returns.extend(Some(v997));
8853
0
                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
8854
914
                                }
8855
0
                            }
8856
                        }
8857
                        &IntCC::UnsignedGreaterThan => {
8858
25.2k
                            let v541 = C::fits_in_64(ctx, v2.0);
8859
25.2k
                            if let Some(v542) = v541 {
8860
25.2k
                                let v1063 = C::ty_int(ctx, v542);
8861
25.2k
                                if let Some(v1064) = v1063 {
8862
25.2k
                                    let v271 = C::unpack_value_array_2(ctx, v269);
8863
25.2k
                                    let mut v274 = C::inst_data_value_etor_returns::default();
8864
25.2k
                                    C::inst_data_value_etor(ctx, v271.1, &mut v274);
8865
25.2k
                                    let mut v274 = v274.into_context_iter();
8866
48.7k
                                    while let Some(
v27523.5k
) = v274.next(ctx) {
8867
                                        if let &InstructionData::UnaryImm {
8868
16.4k
                                            opcode: ref v278,
8869
16.4k
                                            imm: v279,
8870
23.5k
                                        } = &v275.1 {
8871
16.4k
                                            if let &Opcode::Iconst = v278 {
8872
16.4k
                                                let v280 = C::u64_from_imm64(ctx, v279);
8873
16.4k
                                                if v280 == 0x0_u64 {
8874
0
                                                    let v1068 = constructor_ne(ctx, v1064, v271.0, v271.1);
8875
                                                    // Rule at src/opts/icmp.isle line 107.
8876
0
                                                    returns.extend(Some(v1068));
8877
0
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
8878
16.4k
                                                }
8879
16.4k
                                                let v1071 = C::ty_umax(ctx, v275.0);
8880
16.4k
                                                let v1072 = C::u64_eq(ctx, v280, v1071);
8881
16.4k
                                                if v1072 == true {
8882
0
                                                    let v1065 = constructor_iconst_u(ctx, v1064, 0x0_u64);
8883
0
                                                    let v1066 = C::subsume(ctx, v1065);
8884
                                                    // Rule at src/opts/icmp.isle line 125.
8885
0
                                                    returns.extend(Some(v1066));
8886
0
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
8887
16.4k
                                                }
8888
0
                                            }
8889
7.13k
                                        }
8890
                                    }
8891
0
                                }
8892
0
                            }
8893
25.2k
                            let v52 = C::ty_int(ctx, v2.0);
8894
25.2k
                            if let Some(v53) = v52 {
8895
25.2k
                                let v271 = C::unpack_value_array_2(ctx, v269);
8896
25.2k
                                if v271.0 == v271.1 {
8897
3
                                    let v55 = constructor_iconst_u(ctx, v53, 0x0_u64);
8898
3
                                    let v56 = C::subsume(ctx, v55);
8899
                                    // Rule at src/opts/icmp.isle line 6.
8900
3
                                    returns.extend(Some(v56));
8901
3
                                    if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
8902
25.2k
                                }
8903
0
                            }
8904
                        }
8905
                        &IntCC::UnsignedGreaterThanOrEqual => {
8906
39.2k
                            let v271 = C::unpack_value_array_2(ctx, v269);
8907
39.2k
                            let mut v274 = C::inst_data_value_etor_returns::default();
8908
39.2k
                            C::inst_data_value_etor(ctx, v271.1, &mut v274);
8909
39.2k
                            let mut v274 = v274.into_context_iter();
8910
77.7k
                            while let Some(
v27538.5k
) = v274.next(ctx) {
8911
                                if let &InstructionData::UnaryImm {
8912
32.8k
                                    opcode: ref v278,
8913
32.8k
                                    imm: v279,
8914
38.5k
                                } = &v275.1 {
8915
32.8k
                                    if let &Opcode::Iconst = v278 {
8916
32.8k
                                        let v280 = C::u64_from_imm64(ctx, v279);
8917
32.8k
                                        match v280 {
8918
                                            0x0_u64 => {
8919
0
                                                let v541 = C::fits_in_64(ctx, v2.0);
8920
0
                                                if let Some(v542) = v541 {
8921
0
                                                    let v1063 = C::ty_int(ctx, v542);
8922
0
                                                    if let Some(v1064) = v1063 {
8923
0
                                                        let v1069 = constructor_iconst_u(ctx, v1064, 0x1_u64);
8924
0
                                                        let v1070 = C::subsume(ctx, v1069);
8925
                                                        // Rule at src/opts/icmp.isle line 111.
8926
0
                                                        returns.extend(Some(v1070));
8927
0
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
8928
0
                                                    }
8929
0
                                                }
8930
                                            }
8931
                                            0x1_u64 => {
8932
0
                                                let v1091 = constructor_iconst_u(ctx, v275.0, 0x0_u64);
8933
0
                                                let v1092 = constructor_ne(ctx, v2.0, v271.0, v1091);
8934
                                                // Rule at src/opts/icmp.isle line 185.
8935
0
                                                returns.extend(Some(v1092));
8936
0
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
8937
                                            }
8938
32.8k
                                            _ => {}
8939
                                        }
8940
32.8k
                                        let v541 = C::fits_in_64(ctx, v2.0);
8941
32.8k
                                        if let Some(v542) = v541 {
8942
32.8k
                                            let v1063 = C::ty_int(ctx, v542);
8943
32.8k
                                            if let Some(v1064) = v1063 {
8944
32.8k
                                                let v1071 = C::ty_umax(ctx, v275.0);
8945
32.8k
                                                let v1072 = C::u64_eq(ctx, v280, v1071);
8946
32.8k
                                                if v1072 == true {
8947
0
                                                    let v1067 = constructor_eq(ctx, v1064, v271.0, v271.1);
8948
                                                    // Rule at src/opts/icmp.isle line 130.
8949
0
                                                    returns.extend(Some(v1067));
8950
0
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
8951
32.8k
                                                }
8952
0
                                            }
8953
0
                                        }
8954
0
                                    }
8955
5.65k
                                }
8956
                            }
8957
39.2k
                            let v52 = C::ty_int(ctx, v2.0);
8958
39.2k
                            if let Some(v53) = v52 {
8959
39.2k
                                if v271.0 == v271.1 {
8960
0
                                    let v996 = constructor_iconst_u(ctx, v53, 0x1_u64);
8961
0
                                    let v997 = C::subsume(ctx, v996);
8962
                                    // Rule at src/opts/icmp.isle line 7.
8963
0
                                    returns.extend(Some(v997));
8964
0
                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
8965
39.2k
                                }
8966
0
                            }
8967
                        }
8968
                        &IntCC::UnsignedLessThan => {
8969
28.8k
                            let v271 = C::unpack_value_array_2(ctx, v269);
8970
28.8k
                            let mut v274 = C::inst_data_value_etor_returns::default();
8971
28.8k
                            C::inst_data_value_etor(ctx, v271.1, &mut v274);
8972
28.8k
                            let mut v274 = v274.into_context_iter();
8973
55.6k
                            while let Some(
v27526.8k
) = v274.next(ctx) {
8974
                                if let &InstructionData::UnaryImm {
8975
14.3k
                                    opcode: ref v278,
8976
14.3k
                                    imm: v279,
8977
26.8k
                                } = &v275.1 {
8978
14.3k
                                    if let &Opcode::Iconst = v278 {
8979
14.3k
                                        let v280 = C::u64_from_imm64(ctx, v279);
8980
14.3k
                                        match v280 {
8981
                                            0x0_u64 => {
8982
51
                                                let v541 = C::fits_in_64(ctx, v2.0);
8983
51
                                                if let Some(v542) = v541 {
8984
51
                                                    let v1063 = C::ty_int(ctx, v542);
8985
51
                                                    if let Some(v1064) = v1063 {
8986
51
                                                        let v1065 = constructor_iconst_u(ctx, v1064, 0x0_u64);
8987
51
                                                        let v1066 = C::subsume(ctx, v1065);
8988
                                                        // Rule at src/opts/icmp.isle line 99.
8989
51
                                                        returns.extend(Some(v1066));
8990
51
                                                        if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
8991
0
                                                    }
8992
0
                                                }
8993
                                            }
8994
                                            0x1_u64 => {
8995
6
                                                let v1091 = constructor_iconst_u(ctx, v275.0, 0x0_u64);
8996
6
                                                let v1093 = constructor_eq(ctx, v2.0, v271.0, v1091);
8997
                                                // Rule at src/opts/icmp.isle line 188.
8998
6
                                                returns.extend(Some(v1093));
8999
6
                                                if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
9000
                                            }
9001
14.2k
                                            _ => {}
9002
                                        }
9003
14.3k
                                        let v541 = C::fits_in_64(ctx, v2.0);
9004
14.3k
                                        if let Some(v542) = v541 {
9005
14.3k
                                            let v1063 = C::ty_int(ctx, v542);
9006
14.3k
                                            if let Some(v1064) = v1063 {
9007
14.3k
                                                let v1071 = C::ty_umax(ctx, v275.0);
9008
14.3k
                                                let v1072 = C::u64_eq(ctx, v280, v1071);
9009
14.3k
                                                if v1072 == true {
9010
0
                                                    let v1068 = constructor_ne(ctx, v1064, v271.0, v271.1);
9011
                                                    // Rule at src/opts/icmp.isle line 115.
9012
0
                                                    returns.extend(Some(v1068));
9013
0
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
9014
14.3k
                                                }
9015
0
                                            }
9016
0
                                        }
9017
0
                                    }
9018
12.5k
                                }
9019
                            }
9020
28.8k
                            let v52 = C::ty_int(ctx, v2.0);
9021
28.8k
                            if let Some(v53) = v52 {
9022
28.8k
                                if v271.0 == v271.1 {
9023
29
                                    let v55 = constructor_iconst_u(ctx, v53, 0x0_u64);
9024
29
                                    let v56 = C::subsume(ctx, v55);
9025
                                    // Rule at src/opts/icmp.isle line 10.
9026
29
                                    returns.extend(Some(v56));
9027
29
                                    if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
9028
28.7k
                                }
9029
0
                            }
9030
                        }
9031
                        &IntCC::UnsignedLessThanOrEqual => {
9032
4.91k
                            let v541 = C::fits_in_64(ctx, v2.0);
9033
4.91k
                            if let Some(v542) = v541 {
9034
4.91k
                                let v1063 = C::ty_int(ctx, v542);
9035
4.91k
                                if let Some(v1064) = v1063 {
9036
4.91k
                                    let v271 = C::unpack_value_array_2(ctx, v269);
9037
4.91k
                                    let mut v274 = C::inst_data_value_etor_returns::default();
9038
4.91k
                                    C::inst_data_value_etor(ctx, v271.1, &mut v274);
9039
4.91k
                                    let mut v274 = v274.into_context_iter();
9040
9.20k
                                    while let Some(
v2754.29k
) = v274.next(ctx) {
9041
                                        if let &InstructionData::UnaryImm {
9042
1.49k
                                            opcode: ref v278,
9043
1.49k
                                            imm: v279,
9044
4.29k
                                        } = &v275.1 {
9045
1.49k
                                            if let &Opcode::Iconst = v278 {
9046
1.49k
                                                let v280 = C::u64_from_imm64(ctx, v279);
9047
1.49k
                                                if v280 == 0x0_u64 {
9048
0
                                                    let v1067 = constructor_eq(ctx, v1064, v271.0, v271.1);
9049
                                                    // Rule at src/opts/icmp.isle line 103.
9050
0
                                                    returns.extend(Some(v1067));
9051
0
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
9052
1.49k
                                                }
9053
1.49k
                                                let v1071 = C::ty_umax(ctx, v275.0);
9054
1.49k
                                                let v1072 = C::u64_eq(ctx, v280, v1071);
9055
1.49k
                                                if v1072 == true {
9056
0
                                                    let v1069 = constructor_iconst_u(ctx, v1064, 0x1_u64);
9057
0
                                                    let v1070 = C::subsume(ctx, v1069);
9058
                                                    // Rule at src/opts/icmp.isle line 120.
9059
0
                                                    returns.extend(Some(v1070));
9060
0
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
9061
1.49k
                                                }
9062
0
                                            }
9063
2.79k
                                        }
9064
                                    }
9065
0
                                }
9066
0
                            }
9067
4.91k
                            let v52 = C::ty_int(ctx, v2.0);
9068
4.91k
                            if let Some(v53) = v52 {
9069
4.91k
                                let v271 = C::unpack_value_array_2(ctx, v269);
9070
4.91k
                                if v271.0 == v271.1 {
9071
0
                                    let v996 = constructor_iconst_u(ctx, v53, 0x1_u64);
9072
0
                                    let v997 = C::subsume(ctx, v996);
9073
                                    // Rule at src/opts/icmp.isle line 11.
9074
0
                                    returns.extend(Some(v997));
9075
0
                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
9076
4.91k
                                }
9077
0
                            }
9078
                        }
9079
0
                        _ => {}
9080
                    }
9081
338k
                    let v271 = C::unpack_value_array_2(ctx, v269);
9082
338k
                    let mut v598 = C::inst_data_value_etor_returns::default();
9083
338k
                    C::inst_data_value_etor(ctx, v271.0, &mut v598);
9084
338k
                    let mut v598 = v598.into_context_iter();
9085
667k
                    while let Some(
v599329k
) = v598.next(ctx) {
9086
329k
                        match &v599.1 {
9087
                            &InstructionData::Unary {
9088
8.71k
                                opcode: ref v945,
9089
8.71k
                                arg: v946,
9090
                            } => {
9091
8.71k
                                if let &Opcode::Sextend = v945 {
9092
209
                                    let v963 = &C::signed_cond_code(ctx, v270);
9093
209
                                    if let Some(
v96482
) = v963 {
9094
82
                                        let mut v953 = C::inst_data_value_tupled_etor_returns::default();
9095
82
                                        C::inst_data_value_tupled_etor(ctx, v271.1, &mut v953);
9096
82
                                        let mut v953 = v953.into_context_iter();
9097
164
                                        while let Some(
v95482
) = v953.next(ctx) {
9098
82
                                            let v955 = C::iconst_sextend_etor(ctx, v954);
9099
82
                                            if let Some(v956) = v955 {
9100
82
                                                if v956.1 == 0_i64 {
9101
55
                                                    let v947 = C::value_type(ctx, v946);
9102
55
                                                    let v960 = constructor_iconst_s(ctx, v947, 0_i64);
9103
55
                                                    let v965 = constructor_icmp(ctx, v947, v270, v946, v960);
9104
                                                    // Rule at src/opts/extends.isle line 43.
9105
55
                                                    returns.extend(Some(v965));
9106
55
                                                    if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
9107
27
                                                }
9108
0
                                            }
9109
                                        }
9110
127
                                    }
9111
8.50k
                                }
9112
                            }
9113
                            &InstructionData::UnaryImm {
9114
897
                                opcode: ref v602,
9115
897
                                imm: v603,
9116
                            } => {
9117
897
                                if let &Opcode::Iconst = v602 {
9118
897
                                    let mut v274 = C::inst_data_value_etor_returns::default();
9119
897
                                    C::inst_data_value_etor(ctx, v271.1, &mut v274);
9120
897
                                    let mut v274 = v274.into_context_iter();
9121
1.79k
                                    while let Some(
v275897
) = v274.next(ctx) {
9122
                                        if let &InstructionData::UnaryImm {
9123
896
                                            opcode: ref v278,
9124
896
                                            imm: v279,
9125
897
                                        } = &v275.1 {
9126
896
                                            if let &Opcode::Iconst = v278 {
9127
896
                                                if v275.0 == v599.0 {
9128
896
                                                    let v604 = C::imm64_icmp(ctx, v599.0, v270, v603, v279);
9129
896
                                                    let v605 = constructor_iconst(ctx, v2.0, v604);
9130
896
                                                    let v606 = C::subsume(ctx, v605);
9131
                                                    // Rule at src/opts/cprop.isle line 80.
9132
896
                                                    returns.extend(Some(v606));
9133
896
                                                    if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
9134
0
                                                }
9135
0
                                            }
9136
1
                                        }
9137
                                    }
9138
897
                                    let v614 = &C::intcc_swap_args(ctx, v270);
9139
897
                                    let v615 = constructor_icmp(ctx, v2.0, v614, v271.1, v271.0);
9140
                                    // Rule at src/opts/cprop.isle line 114.
9141
897
                                    returns.extend(Some(v615));
9142
897
                                    if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
9143
0
                                }
9144
                            }
9145
319k
                            _ => {}
9146
                        }
9147
                    }
9148
0
                }
9149
            }
9150
            &InstructionData::Ternary {
9151
84.7k
                opcode: ref v84,
9152
84.7k
                args: ref v85,
9153
            } => {
9154
84.7k
                match v84 {
9155
                    &Opcode::Select => {
9156
54.9k
                        let v86 = C::unpack_value_array_3(ctx, v85);
9157
54.9k
                        let mut v90 = C::inst_data_value_etor_returns::default();
9158
54.9k
                        C::inst_data_value_etor(ctx, v86.0, &mut v90);
9159
54.9k
                        let mut v90 = v90.into_context_iter();
9160
124k
                        while let Some(
v9169.7k
) = v90.next(ctx) {
9161
69.7k
                            match &v91.1 {
9162
                                &InstructionData::IntCompare {
9163
24.6k
                                    opcode: ref v1099,
9164
24.6k
                                    args: ref v1100,
9165
24.6k
                                    cond: ref v1101,
9166
                                } => {
9167
24.6k
                                    if let &Opcode::Icmp = v1099 {
9168
24.6k
                                        match v1101 {
9169
                                            &IntCC::Equal => {
9170
10.5k
                                                let mut v1115 = C::inst_data_value_etor_returns::default();
9171
10.5k
                                                C::inst_data_value_etor(ctx, v86.2, &mut v1115);
9172
10.5k
                                                let mut v1115 = v1115.into_context_iter();
9173
21.2k
                                                while let Some(
v111610.6k
) = v1115.next(ctx) {
9174
10.6k
                                                    match &v1116.1 {
9175
                                                        &InstructionData::IntCompare {
9176
2.50k
                                                            opcode: ref v1119,
9177
2.50k
                                                            args: ref v1120,
9178
2.50k
                                                            cond: ref v1121,
9179
                                                        } => {
9180
2.50k
                                                            if let &Opcode::Icmp = v1119 {
9181
2.50k
                                                                match v1121 {
9182
                                                                    &IntCC::SignedGreaterThan => {
9183
0
                                                                        let v1102 = C::unpack_value_array_2(ctx, v1100);
9184
0
                                                                        let v1105 = C::value_type(ctx, v1102.0);
9185
0
                                                                        if v1105 == I64 {
9186
0
                                                                            let v1106 = C::value_type(ctx, v1102.1);
9187
0
                                                                            if v1106 == I64 {
9188
0
                                                                                if v2.0 == v1116.0 {
9189
0
                                                                                    let v1122 = C::unpack_value_array_2(ctx, v1120);
9190
0
                                                                                    if v1102.0 == v1122.0 {
9191
0
                                                                                        if v1102.1 == v1122.1 {
9192
0
                                                                                            let mut v96 = C::inst_data_value_etor_returns::default();
9193
0
                                                                                            C::inst_data_value_etor(ctx, v86.1, &mut v96);
9194
0
                                                                                            let mut v96 = v96.into_context_iter();
9195
0
                                                                                            while let Some(v97) = v96.next(ctx) {
9196
                                                                                                if let &InstructionData::IntCompare {
9197
0
                                                                                                    opcode: ref v1107,
9198
0
                                                                                                    args: ref v1108,
9199
0
                                                                                                    cond: ref v1109,
9200
0
                                                                                                } = &v97.1 {
9201
0
                                                                                                    if let &Opcode::Icmp = v1107 {
9202
0
                                                                                                        if let &IntCC::UnsignedGreaterThan = v1109 {
9203
0
                                                                                                            let v1110 = C::unpack_value_array_2(ctx, v1108);
9204
0
                                                                                                            let v1113 = C::value_type(ctx, v1110.0);
9205
0
                                                                                                            if v1113 == I64 {
9206
0
                                                                                                                let v1114 = C::value_type(ctx, v1110.1);
9207
0
                                                                                                                if v1114 == I64 {
9208
0
                                                                                                                    if v2.0 == v97.0 {
9209
0
                                                                                                                        let v1125 = constructor_iconcat(ctx, I64, v1110.0, v1102.0);
9210
0
                                                                                                                        let v1126 = constructor_iconcat(ctx, I64, v1110.1, v1102.1);
9211
0
                                                                                                                        let v1130 = constructor_sgt(ctx, v2.0, v1125, v1126);
9212
                                                                                                                        // Rule at src/opts/icmp.isle line 264.
9213
0
                                                                                                                        returns.extend(Some(v1130));
9214
0
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
9215
0
                                                                                                                    }
9216
0
                                                                                                                }
9217
0
                                                                                                            }
9218
0
                                                                                                        }
9219
0
                                                                                                    }
9220
0
                                                                                                }
9221
                                                                                            }
9222
0
                                                                                        }
9223
0
                                                                                    }
9224
0
                                                                                }
9225
0
                                                                            }
9226
0
                                                                        }
9227
                                                                    }
9228
                                                                    &IntCC::SignedGreaterThanOrEqual => {
9229
0
                                                                        let v1102 = C::unpack_value_array_2(ctx, v1100);
9230
0
                                                                        let v1105 = C::value_type(ctx, v1102.0);
9231
0
                                                                        if v1105 == I64 {
9232
0
                                                                            let v1106 = C::value_type(ctx, v1102.1);
9233
0
                                                                            if v1106 == I64 {
9234
0
                                                                                if v2.0 == v1116.0 {
9235
0
                                                                                    let v1122 = C::unpack_value_array_2(ctx, v1120);
9236
0
                                                                                    if v1102.0 == v1122.0 {
9237
0
                                                                                        if v1102.1 == v1122.1 {
9238
0
                                                                                            let mut v96 = C::inst_data_value_etor_returns::default();
9239
0
                                                                                            C::inst_data_value_etor(ctx, v86.1, &mut v96);
9240
0
                                                                                            let mut v96 = v96.into_context_iter();
9241
0
                                                                                            while let Some(v97) = v96.next(ctx) {
9242
                                                                                                if let &InstructionData::IntCompare {
9243
0
                                                                                                    opcode: ref v1107,
9244
0
                                                                                                    args: ref v1108,
9245
0
                                                                                                    cond: ref v1109,
9246
0
                                                                                                } = &v97.1 {
9247
0
                                                                                                    if let &Opcode::Icmp = v1107 {
9248
0
                                                                                                        if let &IntCC::UnsignedGreaterThanOrEqual = v1109 {
9249
0
                                                                                                            let v1110 = C::unpack_value_array_2(ctx, v1108);
9250
0
                                                                                                            let v1113 = C::value_type(ctx, v1110.0);
9251
0
                                                                                                            if v1113 == I64 {
9252
0
                                                                                                                let v1114 = C::value_type(ctx, v1110.1);
9253
0
                                                                                                                if v1114 == I64 {
9254
0
                                                                                                                    if v2.0 == v97.0 {
9255
0
                                                                                                                        let v1125 = constructor_iconcat(ctx, I64, v1110.0, v1102.0);
9256
0
                                                                                                                        let v1126 = constructor_iconcat(ctx, I64, v1110.1, v1102.1);
9257
0
                                                                                                                        let v1128 = constructor_sge(ctx, v2.0, v1125, v1126);
9258
                                                                                                                        // Rule at src/opts/icmp.isle line 254.
9259
0
                                                                                                                        returns.extend(Some(v1128));
9260
0
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
9261
0
                                                                                                                    }
9262
0
                                                                                                                }
9263
0
                                                                                                            }
9264
0
                                                                                                        }
9265
0
                                                                                                    }
9266
0
                                                                                                }
9267
                                                                                            }
9268
0
                                                                                        }
9269
0
                                                                                    }
9270
0
                                                                                }
9271
0
                                                                            }
9272
0
                                                                        }
9273
                                                                    }
9274
                                                                    &IntCC::SignedLessThan => {
9275
0
                                                                        let v1102 = C::unpack_value_array_2(ctx, v1100);
9276
0
                                                                        let v1105 = C::value_type(ctx, v1102.0);
9277
0
                                                                        if v1105 == I64 {
9278
0
                                                                            let v1106 = C::value_type(ctx, v1102.1);
9279
0
                                                                            if v1106 == I64 {
9280
0
                                                                                if v2.0 == v1116.0 {
9281
0
                                                                                    let v1122 = C::unpack_value_array_2(ctx, v1120);
9282
0
                                                                                    if v1102.0 == v1122.0 {
9283
0
                                                                                        if v1102.1 == v1122.1 {
9284
0
                                                                                            let mut v96 = C::inst_data_value_etor_returns::default();
9285
0
                                                                                            C::inst_data_value_etor(ctx, v86.1, &mut v96);
9286
0
                                                                                            let mut v96 = v96.into_context_iter();
9287
0
                                                                                            while let Some(v97) = v96.next(ctx) {
9288
                                                                                                if let &InstructionData::IntCompare {
9289
0
                                                                                                    opcode: ref v1107,
9290
0
                                                                                                    args: ref v1108,
9291
0
                                                                                                    cond: ref v1109,
9292
0
                                                                                                } = &v97.1 {
9293
0
                                                                                                    if let &Opcode::Icmp = v1107 {
9294
0
                                                                                                        if let &IntCC::UnsignedLessThan = v1109 {
9295
0
                                                                                                            let v1110 = C::unpack_value_array_2(ctx, v1108);
9296
0
                                                                                                            let v1113 = C::value_type(ctx, v1110.0);
9297
0
                                                                                                            if v1113 == I64 {
9298
0
                                                                                                                let v1114 = C::value_type(ctx, v1110.1);
9299
0
                                                                                                                if v1114 == I64 {
9300
0
                                                                                                                    if v2.0 == v97.0 {
9301
0
                                                                                                                        let v1125 = constructor_iconcat(ctx, I64, v1110.0, v1102.0);
9302
0
                                                                                                                        let v1126 = constructor_iconcat(ctx, I64, v1110.1, v1102.1);
9303
0
                                                                                                                        let v1134 = constructor_slt(ctx, v2.0, v1125, v1126);
9304
                                                                                                                        // Rule at src/opts/icmp.isle line 284.
9305
0
                                                                                                                        returns.extend(Some(v1134));
9306
0
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
9307
0
                                                                                                                    }
9308
0
                                                                                                                }
9309
0
                                                                                                            }
9310
0
                                                                                                        }
9311
0
                                                                                                    }
9312
0
                                                                                                }
9313
                                                                                            }
9314
0
                                                                                        }
9315
0
                                                                                    }
9316
0
                                                                                }
9317
0
                                                                            }
9318
0
                                                                        }
9319
                                                                    }
9320
                                                                    &IntCC::SignedLessThanOrEqual => {
9321
0
                                                                        let v1102 = C::unpack_value_array_2(ctx, v1100);
9322
0
                                                                        let v1105 = C::value_type(ctx, v1102.0);
9323
0
                                                                        if v1105 == I64 {
9324
0
                                                                            let v1106 = C::value_type(ctx, v1102.1);
9325
0
                                                                            if v1106 == I64 {
9326
0
                                                                                if v2.0 == v1116.0 {
9327
0
                                                                                    let v1122 = C::unpack_value_array_2(ctx, v1120);
9328
0
                                                                                    if v1102.0 == v1122.0 {
9329
0
                                                                                        if v1102.1 == v1122.1 {
9330
0
                                                                                            let mut v96 = C::inst_data_value_etor_returns::default();
9331
0
                                                                                            C::inst_data_value_etor(ctx, v86.1, &mut v96);
9332
0
                                                                                            let mut v96 = v96.into_context_iter();
9333
0
                                                                                            while let Some(v97) = v96.next(ctx) {
9334
                                                                                                if let &InstructionData::IntCompare {
9335
0
                                                                                                    opcode: ref v1107,
9336
0
                                                                                                    args: ref v1108,
9337
0
                                                                                                    cond: ref v1109,
9338
0
                                                                                                } = &v97.1 {
9339
0
                                                                                                    if let &Opcode::Icmp = v1107 {
9340
0
                                                                                                        if let &IntCC::UnsignedLessThanOrEqual = v1109 {
9341
0
                                                                                                            let v1110 = C::unpack_value_array_2(ctx, v1108);
9342
0
                                                                                                            let v1113 = C::value_type(ctx, v1110.0);
9343
0
                                                                                                            if v1113 == I64 {
9344
0
                                                                                                                let v1114 = C::value_type(ctx, v1110.1);
9345
0
                                                                                                                if v1114 == I64 {
9346
0
                                                                                                                    if v2.0 == v97.0 {
9347
0
                                                                                                                        let v1125 = constructor_iconcat(ctx, I64, v1110.0, v1102.0);
9348
0
                                                                                                                        let v1126 = constructor_iconcat(ctx, I64, v1110.1, v1102.1);
9349
0
                                                                                                                        let v1132 = constructor_sle(ctx, v2.0, v1125, v1126);
9350
                                                                                                                        // Rule at src/opts/icmp.isle line 274.
9351
0
                                                                                                                        returns.extend(Some(v1132));
9352
0
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
9353
0
                                                                                                                    }
9354
0
                                                                                                                }
9355
0
                                                                                                            }
9356
0
                                                                                                        }
9357
0
                                                                                                    }
9358
0
                                                                                                }
9359
                                                                                            }
9360
0
                                                                                        }
9361
0
                                                                                    }
9362
0
                                                                                }
9363
0
                                                                            }
9364
0
                                                                        }
9365
                                                                    }
9366
                                                                    &IntCC::UnsignedGreaterThan => {
9367
787
                                                                        let v1102 = C::unpack_value_array_2(ctx, v1100);
9368
787
                                                                        let v1105 = C::value_type(ctx, v1102.0);
9369
787
                                                                        if v1105 == I64 {
9370
787
                                                                            let v1106 = C::value_type(ctx, v1102.1);
9371
787
                                                                            if v1106 == I64 {
9372
787
                                                                                if v2.0 == v1116.0 {
9373
787
                                                                                    let v1122 = C::unpack_value_array_2(ctx, v1120);
9374
787
                                                                                    if v1102.0 == v1122.0 {
9375
781
                                                                                        if v1102.1 == v1122.1 {
9376
781
                                                                                            let mut v96 = C::inst_data_value_etor_returns::default();
9377
781
                                                                                            C::inst_data_value_etor(ctx, v86.1, &mut v96);
9378
781
                                                                                            let mut v96 = v96.into_context_iter();
9379
1.56k
                                                                                            while let Some(
v97781
) = v96.next(ctx) {
9380
                                                                                                if let &InstructionData::IntCompare {
9381
781
                                                                                                    opcode: ref v1107,
9382
781
                                                                                                    args: ref v1108,
9383
781
                                                                                                    cond: ref v1109,
9384
781
                                                                                                } = &v97.1 {
9385
781
                                                                                                    if let &Opcode::Icmp = v1107 {
9386
781
                                                                                                        if let &IntCC::UnsignedGreaterThan = v1109 {
9387
781
                                                                                                            let v1110 = C::unpack_value_array_2(ctx, v1108);
9388
781
                                                                                                            let v1113 = C::value_type(ctx, v1110.0);
9389
781
                                                                                                            if v1113 == I64 {
9390
781
                                                                                                                let v1114 = C::value_type(ctx, v1110.1);
9391
781
                                                                                                                if v1114 == I64 {
9392
781
                                                                                                                    if v2.0 == v97.0 {
9393
781
                                                                                                                        let v1125 = constructor_iconcat(ctx, I64, v1110.0, v1102.0);
9394
781
                                                                                                                        let v1126 = constructor_iconcat(ctx, I64, v1110.1, v1102.1);
9395
781
                                                                                                                        let v1129 = constructor_ugt(ctx, v2.0, v1125, v1126);
9396
                                                                                                                        // Rule at src/opts/icmp.isle line 259.
9397
781
                                                                                                                        returns.extend(Some(v1129));
9398
781
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
9399
0
                                                                                                                    }
9400
0
                                                                                                                }
9401
0
                                                                                                            }
9402
0
                                                                                                        }
9403
0
                                                                                                    }
9404
0
                                                                                                }
9405
                                                                                            }
9406
0
                                                                                        }
9407
6
                                                                                    }
9408
0
                                                                                }
9409
0
                                                                            }
9410
0
                                                                        }
9411
                                                                    }
9412
                                                                    &IntCC::UnsignedGreaterThanOrEqual => {
9413
72
                                                                        let v1102 = C::unpack_value_array_2(ctx, v1100);
9414
72
                                                                        let v1105 = C::value_type(ctx, v1102.0);
9415
72
                                                                        if v1105 == I64 {
9416
72
                                                                            let v1106 = C::value_type(ctx, v1102.1);
9417
72
                                                                            if v1106 == I64 {
9418
72
                                                                                if v2.0 == v1116.0 {
9419
72
                                                                                    let v1122 = C::unpack_value_array_2(ctx, v1120);
9420
72
                                                                                    if v1102.0 == v1122.0 {
9421
72
                                                                                        if v1102.1 == v1122.1 {
9422
72
                                                                                            let mut v96 = C::inst_data_value_etor_returns::default();
9423
72
                                                                                            C::inst_data_value_etor(ctx, v86.1, &mut v96);
9424
72
                                                                                            let mut v96 = v96.into_context_iter();
9425
144
                                                                                            while let Some(
v9772
) = v96.next(ctx) {
9426
                                                                                                if let &InstructionData::IntCompare {
9427
72
                                                                                                    opcode: ref v1107,
9428
72
                                                                                                    args: ref v1108,
9429
72
                                                                                                    cond: ref v1109,
9430
72
                                                                                                } = &v97.1 {
9431
72
                                                                                                    if let &Opcode::Icmp = v1107 {
9432
72
                                                                                                        if let &IntCC::UnsignedGreaterThanOrEqual = v1109 {
9433
72
                                                                                                            let v1110 = C::unpack_value_array_2(ctx, v1108);
9434
72
                                                                                                            let v1113 = C::value_type(ctx, v1110.0);
9435
72
                                                                                                            if v1113 == I64 {
9436
72
                                                                                                                let v1114 = C::value_type(ctx, v1110.1);
9437
72
                                                                                                                if v1114 == I64 {
9438
72
                                                                                                                    if v2.0 == v97.0 {
9439
72
                                                                                                                        let v1125 = constructor_iconcat(ctx, I64, v1110.0, v1102.0);
9440
72
                                                                                                                        let v1126 = constructor_iconcat(ctx, I64, v1110.1, v1102.1);
9441
72
                                                                                                                        let v1127 = constructor_uge(ctx, v2.0, v1125, v1126);
9442
                                                                                                                        // Rule at src/opts/icmp.isle line 249.
9443
72
                                                                                                                        returns.extend(Some(v1127));
9444
72
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
9445
0
                                                                                                                    }
9446
0
                                                                                                                }
9447
0
                                                                                                            }
9448
0
                                                                                                        }
9449
0
                                                                                                    }
9450
0
                                                                                                }
9451
                                                                                            }
9452
0
                                                                                        }
9453
0
                                                                                    }
9454
0
                                                                                }
9455
0
                                                                            }
9456
0
                                                                        }
9457
                                                                    }
9458
                                                                    &IntCC::UnsignedLessThan => {
9459
1.09k
                                                                        let v1102 = C::unpack_value_array_2(ctx, v1100);
9460
1.09k
                                                                        let v1105 = C::value_type(ctx, v1102.0);
9461
1.09k
                                                                        if v1105 == I64 {
9462
1.09k
                                                                            let v1106 = C::value_type(ctx, v1102.1);
9463
1.09k
                                                                            if v1106 == I64 {
9464
1.09k
                                                                                if v2.0 == v1116.0 {
9465
1.09k
                                                                                    let v1122 = C::unpack_value_array_2(ctx, v1120);
9466
1.09k
                                                                                    if v1102.0 == v1122.0 {
9467
973
                                                                                        if v1102.1 == v1122.1 {
9468
973
                                                                                            let mut v96 = C::inst_data_value_etor_returns::default();
9469
973
                                                                                            C::inst_data_value_etor(ctx, v86.1, &mut v96);
9470
973
                                                                                            let mut v96 = v96.into_context_iter();
9471
1.94k
                                                                                            while let Some(
v97973
) = v96.next(ctx) {
9472
                                                                                                if let &InstructionData::IntCompare {
9473
973
                                                                                                    opcode: ref v1107,
9474
973
                                                                                                    args: ref v1108,
9475
973
                                                                                                    cond: ref v1109,
9476
973
                                                                                                } = &v97.1 {
9477
973
                                                                                                    if let &Opcode::Icmp = v1107 {
9478
973
                                                                                                        if let &IntCC::UnsignedLessThan = v1109 {
9479
973
                                                                                                            let v1110 = C::unpack_value_array_2(ctx, v1108);
9480
973
                                                                                                            let v1113 = C::value_type(ctx, v1110.0);
9481
973
                                                                                                            if v1113 == I64 {
9482
973
                                                                                                                let v1114 = C::value_type(ctx, v1110.1);
9483
973
                                                                                                                if v1114 == I64 {
9484
973
                                                                                                                    if v2.0 == v97.0 {
9485
973
                                                                                                                        let v1125 = constructor_iconcat(ctx, I64, v1110.0, v1102.0);
9486
973
                                                                                                                        let v1126 = constructor_iconcat(ctx, I64, v1110.1, v1102.1);
9487
973
                                                                                                                        let v1133 = constructor_ult(ctx, v2.0, v1125, v1126);
9488
                                                                                                                        // Rule at src/opts/icmp.isle line 279.
9489
973
                                                                                                                        returns.extend(Some(v1133));
9490
973
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
9491
0
                                                                                                                    }
9492
0
                                                                                                                }
9493
0
                                                                                                            }
9494
0
                                                                                                        }
9495
0
                                                                                                    }
9496
0
                                                                                                }
9497
                                                                                            }
9498
0
                                                                                        }
9499
123
                                                                                    }
9500
0
                                                                                }
9501
0
                                                                            }
9502
0
                                                                        }
9503
                                                                    }
9504
                                                                    &IntCC::UnsignedLessThanOrEqual => {
9505
87
                                                                        let v1102 = C::unpack_value_array_2(ctx, v1100);
9506
87
                                                                        let v1105 = C::value_type(ctx, v1102.0);
9507
87
                                                                        if v1105 == I64 {
9508
87
                                                                            let v1106 = C::value_type(ctx, v1102.1);
9509
87
                                                                            if v1106 == I64 {
9510
87
                                                                                if v2.0 == v1116.0 {
9511
87
                                                                                    let v1122 = C::unpack_value_array_2(ctx, v1120);
9512
87
                                                                                    if v1102.0 == v1122.0 {
9513
87
                                                                                        if v1102.1 == v1122.1 {
9514
87
                                                                                            let mut v96 = C::inst_data_value_etor_returns::default();
9515
87
                                                                                            C::inst_data_value_etor(ctx, v86.1, &mut v96);
9516
87
                                                                                            let mut v96 = v96.into_context_iter();
9517
174
                                                                                            while let Some(
v9787
) = v96.next(ctx) {
9518
                                                                                                if let &InstructionData::IntCompare {
9519
87
                                                                                                    opcode: ref v1107,
9520
87
                                                                                                    args: ref v1108,
9521
87
                                                                                                    cond: ref v1109,
9522
87
                                                                                                } = &v97.1 {
9523
87
                                                                                                    if let &Opcode::Icmp = v1107 {
9524
87
                                                                                                        if let &IntCC::UnsignedLessThanOrEqual = v1109 {
9525
87
                                                                                                            let v1110 = C::unpack_value_array_2(ctx, v1108);
9526
87
                                                                                                            let v1113 = C::value_type(ctx, v1110.0);
9527
87
                                                                                                            if v1113 == I64 {
9528
87
                                                                                                                let v1114 = C::value_type(ctx, v1110.1);
9529
87
                                                                                                                if v1114 == I64 {
9530
87
                                                                                                                    if v2.0 == v97.0 {
9531
87
                                                                                                                        let v1125 = constructor_iconcat(ctx, I64, v1110.0, v1102.0);
9532
87
                                                                                                                        let v1126 = constructor_iconcat(ctx, I64, v1110.1, v1102.1);
9533
87
                                                                                                                        let v1131 = constructor_ule(ctx, v2.0, v1125, v1126);
9534
                                                                                                                        // Rule at src/opts/icmp.isle line 269.
9535
87
                                                                                                                        returns.extend(Some(v1131));
9536
87
                                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
9537
0
                                                                                                                    }
9538
0
                                                                                                                }
9539
0
                                                                                                            }
9540
0
                                                                                                        }
9541
0
                                                                                                    }
9542
0
                                                                                                }
9543
                                                                                            }
9544
0
                                                                                        }
9545
0
                                                                                    }
9546
0
                                                                                }
9547
0
                                                                            }
9548
0
                                                                        }
9549
                                                                    }
9550
461
                                                                    _ => {}
9551
                                                                }
9552
0
                                                            }
9553
                                                        }
9554
                                                        &InstructionData::Ternary {
9555
339
                                                            opcode: ref v1310,
9556
339
                                                            args: ref v1311,
9557
                                                        } => {
9558
339
                                                            if let &Opcode::Select = v1310 {
9559
339
                                                                if v2.0 == v1116.0 {
9560
339
                                                                    let mut v1161 = C::inst_data_value_tupled_etor_returns::default();
9561
339
                                                                    C::inst_data_value_tupled_etor(ctx, v86.1, &mut v1161);
9562
339
                                                                    let mut v1161 = v1161.into_context_iter();
9563
832
                                                                    while let Some(
v1162493
) = v1161.next(ctx) {
9564
493
                                                                        let v1163 = C::iconst_sextend_etor(ctx, v1162);
9565
493
                                                                        if let Some(
v1164167
) = v1163 {
9566
167
                                                                            if v1164.1 == 0_i64 {
9567
167
                                                                                if v2.0 == v1164.0 {
9568
167
                                                                                    let v1312 = C::unpack_value_array_3(ctx, v1311);
9569
167
                                                                                    let mut v1316 = C::inst_data_value_etor_returns::default();
9570
167
                                                                                    C::inst_data_value_etor(ctx, v1312.0, &mut v1316);
9571
167
                                                                                    let mut v1316 = v1316.into_context_iter();
9572
634
                                                                                    while let Some(
v1317467
) = v1316.next(ctx) {
9573
                                                                                        if let &InstructionData::IntCompare {
9574
106
                                                                                            opcode: ref v1320,
9575
106
                                                                                            args: ref v1321,
9576
106
                                                                                            cond: ref v1322,
9577
467
                                                                                        } = &v1317.1 {
9578
106
                                                                                            if let &Opcode::Icmp = v1320 {
9579
106
                                                                                                match v1322 {
9580
                                                                                                    &IntCC::SignedGreaterThan => {
9581
0
                                                                                                        if v91.0 == v1317.0 {
9582
0
                                                                                                            let v1102 = C::unpack_value_array_2(ctx, v1100);
9583
0
                                                                                                            let v1323 = C::unpack_value_array_2(ctx, v1321);
9584
0
                                                                                                            if v1102.0 == v1323.0 {
9585
0
                                                                                                                if v1102.1 == v1323.1 {
9586
0
                                                                                                                    let mut v1326 = C::inst_data_value_tupled_etor_returns::default();
9587
0
                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1312.1, &mut v1326);
9588
0
                                                                                                                    let mut v1326 = v1326.into_context_iter();
9589
0
                                                                                                                    while let Some(v1327) = v1326.next(ctx) {
9590
0
                                                                                                                        let v1328 = C::iconst_sextend_etor(ctx, v1327);
9591
0
                                                                                                                        if let Some(v1329) = v1328 {
9592
0
                                                                                                                            if v1329.1 == 1_i64 {
9593
0
                                                                                                                                if v2.0 == v1329.0 {
9594
0
                                                                                                                                    let mut v1332 = C::inst_data_value_tupled_etor_returns::default();
9595
0
                                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1312.2, &mut v1332);
9596
0
                                                                                                                                    let mut v1332 = v1332.into_context_iter();
9597
0
                                                                                                                                    while let Some(v1333) = v1332.next(ctx) {
9598
0
                                                                                                                                        let v1334 = C::iconst_sextend_etor(ctx, v1333);
9599
0
                                                                                                                                        if let Some(v1335) = v1334 {
9600
0
                                                                                                                                            if v1335.1 == -1_i64 {
9601
0
                                                                                                                                                if v2.0 == v1335.0 {
9602
0
                                                                                                                                                    let v1348 = constructor_spaceship_s(ctx, v91.0, v1102.0, v1102.1);
9603
0
                                                                                                                                                    let v1349 = constructor_sextend_maybe(ctx, v2.0, v1348);
9604
                                                                                                                                                    // Rule at src/opts/spaceship.isle line 103.
9605
0
                                                                                                                                                    returns.extend(Some(v1349));
9606
0
                                                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
9607
0
                                                                                                                                                }
9608
0
                                                                                                                                            }
9609
0
                                                                                                                                        }
9610
                                                                                                                                    }
9611
0
                                                                                                                                }
9612
0
                                                                                                                            }
9613
0
                                                                                                                        }
9614
                                                                                                                    }
9615
0
                                                                                                                }
9616
0
                                                                                                            }
9617
0
                                                                                                        }
9618
                                                                                                    }
9619
                                                                                                    &IntCC::SignedGreaterThanOrEqual => {
9620
0
                                                                                                        if v91.0 == v1317.0 {
9621
0
                                                                                                            let v1102 = C::unpack_value_array_2(ctx, v1100);
9622
0
                                                                                                            let v1323 = C::unpack_value_array_2(ctx, v1321);
9623
0
                                                                                                            if v1102.0 == v1323.0 {
9624
0
                                                                                                                if v1102.1 == v1323.1 {
9625
0
                                                                                                                    let mut v1326 = C::inst_data_value_tupled_etor_returns::default();
9626
0
                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1312.1, &mut v1326);
9627
0
                                                                                                                    let mut v1326 = v1326.into_context_iter();
9628
0
                                                                                                                    while let Some(v1327) = v1326.next(ctx) {
9629
0
                                                                                                                        let v1328 = C::iconst_sextend_etor(ctx, v1327);
9630
0
                                                                                                                        if let Some(v1329) = v1328 {
9631
0
                                                                                                                            if v1329.1 == 1_i64 {
9632
0
                                                                                                                                if v2.0 == v1329.0 {
9633
0
                                                                                                                                    let mut v1332 = C::inst_data_value_tupled_etor_returns::default();
9634
0
                                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1312.2, &mut v1332);
9635
0
                                                                                                                                    let mut v1332 = v1332.into_context_iter();
9636
0
                                                                                                                                    while let Some(v1333) = v1332.next(ctx) {
9637
0
                                                                                                                                        let v1334 = C::iconst_sextend_etor(ctx, v1333);
9638
0
                                                                                                                                        if let Some(v1335) = v1334 {
9639
0
                                                                                                                                            if v1335.1 == -1_i64 {
9640
0
                                                                                                                                                if v2.0 == v1335.0 {
9641
0
                                                                                                                                                    let v1348 = constructor_spaceship_s(ctx, v91.0, v1102.0, v1102.1);
9642
0
                                                                                                                                                    let v1349 = constructor_sextend_maybe(ctx, v2.0, v1348);
9643
                                                                                                                                                    // Rule at src/opts/spaceship.isle line 110.
9644
0
                                                                                                                                                    returns.extend(Some(v1349));
9645
0
                                                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
9646
0
                                                                                                                                                }
9647
0
                                                                                                                                            }
9648
0
                                                                                                                                        }
9649
                                                                                                                                    }
9650
0
                                                                                                                                }
9651
0
                                                                                                                            }
9652
0
                                                                                                                        }
9653
                                                                                                                    }
9654
0
                                                                                                                }
9655
0
                                                                                                            }
9656
0
                                                                                                        }
9657
                                                                                                    }
9658
                                                                                                    &IntCC::SignedLessThan => {
9659
0
                                                                                                        if v91.0 == v1317.0 {
9660
0
                                                                                                            let v1102 = C::unpack_value_array_2(ctx, v1100);
9661
0
                                                                                                            let v1323 = C::unpack_value_array_2(ctx, v1321);
9662
0
                                                                                                            if v1102.0 == v1323.0 {
9663
0
                                                                                                                if v1102.1 == v1323.1 {
9664
0
                                                                                                                    let mut v1326 = C::inst_data_value_tupled_etor_returns::default();
9665
0
                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1312.1, &mut v1326);
9666
0
                                                                                                                    let mut v1326 = v1326.into_context_iter();
9667
0
                                                                                                                    while let Some(v1327) = v1326.next(ctx) {
9668
0
                                                                                                                        let v1328 = C::iconst_sextend_etor(ctx, v1327);
9669
0
                                                                                                                        if let Some(v1329) = v1328 {
9670
0
                                                                                                                            if v1329.1 == -1_i64 {
9671
0
                                                                                                                                if v2.0 == v1329.0 {
9672
0
                                                                                                                                    let mut v1332 = C::inst_data_value_tupled_etor_returns::default();
9673
0
                                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1312.2, &mut v1332);
9674
0
                                                                                                                                    let mut v1332 = v1332.into_context_iter();
9675
0
                                                                                                                                    while let Some(v1333) = v1332.next(ctx) {
9676
0
                                                                                                                                        let v1334 = C::iconst_sextend_etor(ctx, v1333);
9677
0
                                                                                                                                        if let Some(v1335) = v1334 {
9678
0
                                                                                                                                            if v1335.1 == 1_i64 {
9679
0
                                                                                                                                                if v2.0 == v1335.0 {
9680
0
                                                                                                                                                    let v1348 = constructor_spaceship_s(ctx, v91.0, v1102.0, v1102.1);
9681
0
                                                                                                                                                    let v1349 = constructor_sextend_maybe(ctx, v2.0, v1348);
9682
                                                                                                                                                    // Rule at src/opts/spaceship.isle line 89.
9683
0
                                                                                                                                                    returns.extend(Some(v1349));
9684
0
                                                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
9685
0
                                                                                                                                                }
9686
0
                                                                                                                                            }
9687
0
                                                                                                                                        }
9688
                                                                                                                                    }
9689
0
                                                                                                                                }
9690
0
                                                                                                                            }
9691
0
                                                                                                                        }
9692
                                                                                                                    }
9693
0
                                                                                                                }
9694
0
                                                                                                            }
9695
0
                                                                                                        }
9696
                                                                                                    }
9697
                                                                                                    &IntCC::SignedLessThanOrEqual => {
9698
0
                                                                                                        if v91.0 == v1317.0 {
9699
0
                                                                                                            let v1102 = C::unpack_value_array_2(ctx, v1100);
9700
0
                                                                                                            let v1323 = C::unpack_value_array_2(ctx, v1321);
9701
0
                                                                                                            if v1102.0 == v1323.0 {
9702
0
                                                                                                                if v1102.1 == v1323.1 {
9703
0
                                                                                                                    let mut v1326 = C::inst_data_value_tupled_etor_returns::default();
9704
0
                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1312.1, &mut v1326);
9705
0
                                                                                                                    let mut v1326 = v1326.into_context_iter();
9706
0
                                                                                                                    while let Some(v1327) = v1326.next(ctx) {
9707
0
                                                                                                                        let v1328 = C::iconst_sextend_etor(ctx, v1327);
9708
0
                                                                                                                        if let Some(v1329) = v1328 {
9709
0
                                                                                                                            if v1329.1 == -1_i64 {
9710
0
                                                                                                                                if v2.0 == v1329.0 {
9711
0
                                                                                                                                    let mut v1332 = C::inst_data_value_tupled_etor_returns::default();
9712
0
                                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1312.2, &mut v1332);
9713
0
                                                                                                                                    let mut v1332 = v1332.into_context_iter();
9714
0
                                                                                                                                    while let Some(v1333) = v1332.next(ctx) {
9715
0
                                                                                                                                        let v1334 = C::iconst_sextend_etor(ctx, v1333);
9716
0
                                                                                                                                        if let Some(v1335) = v1334 {
9717
0
                                                                                                                                            if v1335.1 == 1_i64 {
9718
0
                                                                                                                                                if v2.0 == v1335.0 {
9719
0
                                                                                                                                                    let v1348 = constructor_spaceship_s(ctx, v91.0, v1102.0, v1102.1);
9720
0
                                                                                                                                                    let v1349 = constructor_sextend_maybe(ctx, v2.0, v1348);
9721
                                                                                                                                                    // Rule at src/opts/spaceship.isle line 96.
9722
0
                                                                                                                                                    returns.extend(Some(v1349));
9723
0
                                                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
9724
0
                                                                                                                                                }
9725
0
                                                                                                                                            }
9726
0
                                                                                                                                        }
9727
                                                                                                                                    }
9728
0
                                                                                                                                }
9729
0
                                                                                                                            }
9730
0
                                                                                                                        }
9731
                                                                                                                    }
9732
0
                                                                                                                }
9733
0
                                                                                                            }
9734
0
                                                                                                        }
9735
                                                                                                    }
9736
                                                                                                    &IntCC::UnsignedGreaterThan => {
9737
8
                                                                                                        if v91.0 == v1317.0 {
9738
8
                                                                                                            let v1102 = C::unpack_value_array_2(ctx, v1100);
9739
8
                                                                                                            let v1323 = C::unpack_value_array_2(ctx, v1321);
9740
8
                                                                                                            if v1102.0 == v1323.0 {
9741
0
                                                                                                                if v1102.1 == v1323.1 {
9742
0
                                                                                                                    let mut v1326 = C::inst_data_value_tupled_etor_returns::default();
9743
0
                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1312.1, &mut v1326);
9744
0
                                                                                                                    let mut v1326 = v1326.into_context_iter();
9745
0
                                                                                                                    while let Some(v1327) = v1326.next(ctx) {
9746
0
                                                                                                                        let v1328 = C::iconst_sextend_etor(ctx, v1327);
9747
0
                                                                                                                        if let Some(v1329) = v1328 {
9748
0
                                                                                                                            if v1329.1 == 1_i64 {
9749
0
                                                                                                                                if v2.0 == v1329.0 {
9750
0
                                                                                                                                    let mut v1332 = C::inst_data_value_tupled_etor_returns::default();
9751
0
                                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1312.2, &mut v1332);
9752
0
                                                                                                                                    let mut v1332 = v1332.into_context_iter();
9753
0
                                                                                                                                    while let Some(v1333) = v1332.next(ctx) {
9754
0
                                                                                                                                        let v1334 = C::iconst_sextend_etor(ctx, v1333);
9755
0
                                                                                                                                        if let Some(v1335) = v1334 {
9756
0
                                                                                                                                            if v1335.1 == -1_i64 {
9757
0
                                                                                                                                                if v2.0 == v1335.0 {
9758
0
                                                                                                                                                    let v1308 = constructor_spaceship_u(ctx, v91.0, v1102.0, v1102.1);
9759
0
                                                                                                                                                    let v1309 = constructor_sextend_maybe(ctx, v2.0, v1308);
9760
                                                                                                                                                    // Rule at src/opts/spaceship.isle line 38.
9761
0
                                                                                                                                                    returns.extend(Some(v1309));
9762
0
                                                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
9763
0
                                                                                                                                                }
9764
0
                                                                                                                                            }
9765
0
                                                                                                                                        }
9766
                                                                                                                                    }
9767
0
                                                                                                                                }
9768
0
                                                                                                                            }
9769
0
                                                                                                                        }
9770
                                                                                                                    }
9771
0
                                                                                                                }
9772
8
                                                                                                            }
9773
0
                                                                                                        }
9774
                                                                                                    }
9775
                                                                                                    &IntCC::UnsignedGreaterThanOrEqual => {
9776
0
                                                                                                        if v91.0 == v1317.0 {
9777
0
                                                                                                            let v1102 = C::unpack_value_array_2(ctx, v1100);
9778
0
                                                                                                            let v1323 = C::unpack_value_array_2(ctx, v1321);
9779
0
                                                                                                            if v1102.0 == v1323.0 {
9780
0
                                                                                                                if v1102.1 == v1323.1 {
9781
0
                                                                                                                    let mut v1326 = C::inst_data_value_tupled_etor_returns::default();
9782
0
                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1312.1, &mut v1326);
9783
0
                                                                                                                    let mut v1326 = v1326.into_context_iter();
9784
0
                                                                                                                    while let Some(v1327) = v1326.next(ctx) {
9785
0
                                                                                                                        let v1328 = C::iconst_sextend_etor(ctx, v1327);
9786
0
                                                                                                                        if let Some(v1329) = v1328 {
9787
0
                                                                                                                            if v1329.1 == 1_i64 {
9788
0
                                                                                                                                if v2.0 == v1329.0 {
9789
0
                                                                                                                                    let mut v1332 = C::inst_data_value_tupled_etor_returns::default();
9790
0
                                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1312.2, &mut v1332);
9791
0
                                                                                                                                    let mut v1332 = v1332.into_context_iter();
9792
0
                                                                                                                                    while let Some(v1333) = v1332.next(ctx) {
9793
0
                                                                                                                                        let v1334 = C::iconst_sextend_etor(ctx, v1333);
9794
0
                                                                                                                                        if let Some(v1335) = v1334 {
9795
0
                                                                                                                                            if v1335.1 == -1_i64 {
9796
0
                                                                                                                                                if v2.0 == v1335.0 {
9797
0
                                                                                                                                                    let v1308 = constructor_spaceship_u(ctx, v91.0, v1102.0, v1102.1);
9798
0
                                                                                                                                                    let v1309 = constructor_sextend_maybe(ctx, v2.0, v1308);
9799
                                                                                                                                                    // Rule at src/opts/spaceship.isle line 45.
9800
0
                                                                                                                                                    returns.extend(Some(v1309));
9801
0
                                                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
9802
0
                                                                                                                                                }
9803
0
                                                                                                                                            }
9804
0
                                                                                                                                        }
9805
                                                                                                                                    }
9806
0
                                                                                                                                }
9807
0
                                                                                                                            }
9808
0
                                                                                                                        }
9809
                                                                                                                    }
9810
0
                                                                                                                }
9811
0
                                                                                                            }
9812
0
                                                                                                        }
9813
                                                                                                    }
9814
                                                                                                    &IntCC::UnsignedLessThan => {
9815
98
                                                                                                        if v91.0 == v1317.0 {
9816
98
                                                                                                            let v1102 = C::unpack_value_array_2(ctx, v1100);
9817
98
                                                                                                            let v1323 = C::unpack_value_array_2(ctx, v1321);
9818
98
                                                                                                            if v1102.0 == v1323.0 {
9819
6
                                                                                                                if v1102.1 == v1323.1 {
9820
6
                                                                                                                    let mut v1326 = C::inst_data_value_tupled_etor_returns::default();
9821
6
                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1312.1, &mut v1326);
9822
6
                                                                                                                    let mut v1326 = v1326.into_context_iter();
9823
12
                                                                                                                    while let Some(
v13276
) = v1326.next(ctx) {
9824
6
                                                                                                                        let v1328 = C::iconst_sextend_etor(ctx, v1327);
9825
6
                                                                                                                        if let Some(v1329) = v1328 {
9826
6
                                                                                                                            if v1329.1 == -1_i64 {
9827
6
                                                                                                                                if v2.0 == v1329.0 {
9828
6
                                                                                                                                    let mut v1332 = C::inst_data_value_tupled_etor_returns::default();
9829
6
                                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1312.2, &mut v1332);
9830
6
                                                                                                                                    let mut v1332 = v1332.into_context_iter();
9831
12
                                                                                                                                    while let Some(
v13336
) = v1332.next(ctx) {
9832
6
                                                                                                                                        let v1334 = C::iconst_sextend_etor(ctx, v1333);
9833
6
                                                                                                                                        if let Some(
v13350
) = v1334 {
9834
0
                                                                                                                                            if v1335.1 == 1_i64 {
9835
0
                                                                                                                                                if v2.0 == v1335.0 {
9836
0
                                                                                                                                                    let v1308 = constructor_spaceship_u(ctx, v91.0, v1102.0, v1102.1);
9837
0
                                                                                                                                                    let v1309 = constructor_sextend_maybe(ctx, v2.0, v1308);
9838
                                                                                                                                                    // Rule at src/opts/spaceship.isle line 24.
9839
0
                                                                                                                                                    returns.extend(Some(v1309));
9840
0
                                                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
9841
0
                                                                                                                                                }
9842
0
                                                                                                                                            }
9843
6
                                                                                                                                        }
9844
                                                                                                                                    }
9845
0
                                                                                                                                }
9846
0
                                                                                                                            }
9847
0
                                                                                                                        }
9848
                                                                                                                    }
9849
0
                                                                                                                }
9850
92
                                                                                                            }
9851
0
                                                                                                        }
9852
                                                                                                    }
9853
                                                                                                    &IntCC::UnsignedLessThanOrEqual => {
9854
0
                                                                                                        if v91.0 == v1317.0 {
9855
0
                                                                                                            let v1102 = C::unpack_value_array_2(ctx, v1100);
9856
0
                                                                                                            let v1323 = C::unpack_value_array_2(ctx, v1321);
9857
0
                                                                                                            if v1102.0 == v1323.0 {
9858
0
                                                                                                                if v1102.1 == v1323.1 {
9859
0
                                                                                                                    let mut v1326 = C::inst_data_value_tupled_etor_returns::default();
9860
0
                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1312.1, &mut v1326);
9861
0
                                                                                                                    let mut v1326 = v1326.into_context_iter();
9862
0
                                                                                                                    while let Some(v1327) = v1326.next(ctx) {
9863
0
                                                                                                                        let v1328 = C::iconst_sextend_etor(ctx, v1327);
9864
0
                                                                                                                        if let Some(v1329) = v1328 {
9865
0
                                                                                                                            if v1329.1 == -1_i64 {
9866
0
                                                                                                                                if v2.0 == v1329.0 {
9867
0
                                                                                                                                    let mut v1332 = C::inst_data_value_tupled_etor_returns::default();
9868
0
                                                                                                                                    C::inst_data_value_tupled_etor(ctx, v1312.2, &mut v1332);
9869
0
                                                                                                                                    let mut v1332 = v1332.into_context_iter();
9870
0
                                                                                                                                    while let Some(v1333) = v1332.next(ctx) {
9871
0
                                                                                                                                        let v1334 = C::iconst_sextend_etor(ctx, v1333);
9872
0
                                                                                                                                        if let Some(v1335) = v1334 {
9873
0
                                                                                                                                            if v1335.1 == 1_i64 {
9874
0
                                                                                                                                                if v2.0 == v1335.0 {
9875
0
                                                                                                                                                    let v1308 = constructor_spaceship_u(ctx, v91.0, v1102.0, v1102.1);
9876
0
                                                                                                                                                    let v1309 = constructor_sextend_maybe(ctx, v2.0, v1308);
9877
                                                                                                                                                    // Rule at src/opts/spaceship.isle line 31.
9878
0
                                                                                                                                                    returns.extend(Some(v1309));
9879
0
                                                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
9880
0
                                                                                                                                                }
9881
0
                                                                                                                                            }
9882
0
                                                                                                                                        }
9883
                                                                                                                                    }
9884
0
                                                                                                                                }
9885
0
                                                                                                                            }
9886
0
                                                                                                                        }
9887
                                                                                                                    }
9888
0
                                                                                                                }
9889
0
                                                                                                            }
9890
0
                                                                                                        }
9891
                                                                                                    }
9892
0
                                                                                                    _ => {}
9893
                                                                                                }
9894
0
                                                                                            }
9895
361
                                                                                        }
9896
                                                                                    }
9897
0
                                                                                }
9898
0
                                                                            }
9899
326
                                                                        }
9900
                                                                    }
9901
0
                                                                }
9902
0
                                                            }
9903
                                                        }
9904
7.82k
                                                        _ => {}
9905
                                                    }
9906
                                                }
9907
                                            }
9908
                                            &IntCC::SignedGreaterThan => {
9909
4
                                                let mut v1115 = C::inst_data_value_etor_returns::default();
9910
4
                                                C::inst_data_value_etor(ctx, v86.2, &mut v1115);
9911
4
                                                let mut v1115 = v1115.into_context_iter();
9912
8
                                                while let Some(
v11164
) = v1115.next(ctx) {
9913
                                                    if let &InstructionData::Unary {
9914
0
                                                        opcode: ref v1197,
9915
0
                                                        arg: v1198,
9916
4
                                                    } = &v1116.1 {
9917
0
                                                        match v1197 {
9918
                                                            &Opcode::Ineg => {
9919
0
                                                                if v91.0 == v1116.0 {
9920
0
                                                                    let mut v1161 = C::inst_data_value_tupled_etor_returns::default();
9921
0
                                                                    C::inst_data_value_tupled_etor(ctx, v86.1, &mut v1161);
9922
0
                                                                    let mut v1161 = v1161.into_context_iter();
9923
0
                                                                    while let Some(v1162) = v1161.next(ctx) {
9924
0
                                                                        let v1163 = C::iconst_sextend_etor(ctx, v1162);
9925
0
                                                                        if let Some(v1164) = v1163 {
9926
0
                                                                            if v1164.1 == 1_i64 {
9927
0
                                                                                if v2.0 == v1164.0 {
9928
0
                                                                                    let mut v1338 = C::inst_data_value_etor_returns::default();
9929
0
                                                                                    C::inst_data_value_etor(ctx, v1198, &mut v1338);
9930
0
                                                                                    let mut v1338 = v1338.into_context_iter();
9931
0
                                                                                    while let Some(v1339) = v1338.next(ctx) {
9932
                                                                                        if let &InstructionData::IntCompare {
9933
0
                                                                                            opcode: ref v1342,
9934
0
                                                                                            args: ref v1343,
9935
0
                                                                                            cond: ref v1344,
9936
0
                                                                                        } = &v1339.1 {
9937
0
                                                                                            if let &Opcode::Icmp = v1342 {
9938
0
                                                                                                match v1344 {
9939
                                                                                                    &IntCC::NotEqual => {
9940
0
                                                                                                        if v91.0 == v1339.0 {
9941
0
                                                                                                            let v1102 = C::unpack_value_array_2(ctx, v1100);
9942
0
                                                                                                            let v1345 = C::unpack_value_array_2(ctx, v1343);
9943
0
                                                                                                            if v1102.0 == v1345.0 {
9944
0
                                                                                                                if v1102.1 == v1345.1 {
9945
0
                                                                                                                    let v1348 = constructor_spaceship_s(ctx, v91.0, v1102.0, v1102.1);
9946
0
                                                                                                                    let v1349 = constructor_sextend_maybe(ctx, v2.0, v1348);
9947
                                                                                                                    // Rule at src/opts/spaceship.isle line 129.
9948
0
                                                                                                                    returns.extend(Some(v1349));
9949
0
                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
9950
0
                                                                                                                }
9951
0
                                                                                                            }
9952
0
                                                                                                        }
9953
                                                                                                    }
9954
                                                                                                    &IntCC::SignedLessThan => {
9955
0
                                                                                                        if v91.0 == v1339.0 {
9956
0
                                                                                                            let v1102 = C::unpack_value_array_2(ctx, v1100);
9957
0
                                                                                                            let v1345 = C::unpack_value_array_2(ctx, v1343);
9958
0
                                                                                                            if v1102.0 == v1345.0 {
9959
0
                                                                                                                if v1102.1 == v1345.1 {
9960
0
                                                                                                                    let v1348 = constructor_spaceship_s(ctx, v91.0, v1102.0, v1102.1);
9961
0
                                                                                                                    let v1349 = constructor_sextend_maybe(ctx, v2.0, v1348);
9962
                                                                                                                    // Rule at src/opts/spaceship.isle line 119.
9963
0
                                                                                                                    returns.extend(Some(v1349));
9964
0
                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
9965
0
                                                                                                                }
9966
0
                                                                                                            }
9967
0
                                                                                                        }
9968
                                                                                                    }
9969
0
                                                                                                    _ => {}
9970
                                                                                                }
9971
0
                                                                                            }
9972
0
                                                                                        }
9973
                                                                                    }
9974
0
                                                                                }
9975
0
                                                                            }
9976
0
                                                                        }
9977
                                                                    }
9978
0
                                                                }
9979
0
                                                                if v2.0 == v1116.0 {
9980
0
                                                                    let v1102 = C::unpack_value_array_2(ctx, v1100);
9981
0
                                                                    if v86.1 == v1102.0 {
9982
0
                                                                        if v86.1 == v1198 {
9983
0
                                                                            let mut v1203 = C::inst_data_value_etor_returns::default();
9984
0
                                                                            C::inst_data_value_etor(ctx, v1102.1, &mut v1203);
9985
0
                                                                            let mut v1203 = v1203.into_context_iter();
9986
0
                                                                            while let Some(v1204) = v1203.next(ctx) {
9987
                                                                                if let &InstructionData::UnaryImm {
9988
0
                                                                                    opcode: ref v1207,
9989
0
                                                                                    imm: v1208,
9990
0
                                                                                } = &v1204.1 {
9991
0
                                                                                    if let &Opcode::Iconst = v1207 {
9992
0
                                                                                        let v1209 = C::u64_from_imm64(ctx, v1208);
9993
0
                                                                                        if v1209 == 0x0_u64 {
9994
0
                                                                                            if v2.0 == v1204.0 {
9995
0
                                                                                                let v1210 = constructor_iabs(ctx, v2.0, v1102.0);
9996
0
                                                                                                let v1211 = C::subsume(ctx, v1210);
9997
                                                                                                // Rule at src/opts/selects.isle line 89.
9998
0
                                                                                                returns.extend(Some(v1211));
9999
0
                                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
10000
0
                                                                                            }
10001
0
                                                                                        }
10002
0
                                                                                    }
10003
0
                                                                                }
10004
                                                                            }
10005
0
                                                                        }
10006
0
                                                                    }
10007
0
                                                                }
10008
                                                            }
10009
                                                            &Opcode::Bmask => {
10010
0
                                                                if v2.0 == v1116.0 {
10011
0
                                                                    let mut v1161 = C::inst_data_value_tupled_etor_returns::default();
10012
0
                                                                    C::inst_data_value_tupled_etor(ctx, v86.1, &mut v1161);
10013
0
                                                                    let mut v1161 = v1161.into_context_iter();
10014
0
                                                                    while let Some(v1162) = v1161.next(ctx) {
10015
0
                                                                        let v1163 = C::iconst_sextend_etor(ctx, v1162);
10016
0
                                                                        if let Some(v1164) = v1163 {
10017
0
                                                                            if v1164.1 == 1_i64 {
10018
0
                                                                                if v2.0 == v1164.0 {
10019
0
                                                                                    let mut v1338 = C::inst_data_value_etor_returns::default();
10020
0
                                                                                    C::inst_data_value_etor(ctx, v1198, &mut v1338);
10021
0
                                                                                    let mut v1338 = v1338.into_context_iter();
10022
0
                                                                                    while let Some(v1339) = v1338.next(ctx) {
10023
                                                                                        if let &InstructionData::IntCompare {
10024
0
                                                                                            opcode: ref v1342,
10025
0
                                                                                            args: ref v1343,
10026
0
                                                                                            cond: ref v1344,
10027
0
                                                                                        } = &v1339.1 {
10028
0
                                                                                            if let &Opcode::Icmp = v1342 {
10029
0
                                                                                                match v1344 {
10030
                                                                                                    &IntCC::NotEqual => {
10031
0
                                                                                                        if v91.0 == v1339.0 {
10032
0
                                                                                                            let v1102 = C::unpack_value_array_2(ctx, v1100);
10033
0
                                                                                                            let v1345 = C::unpack_value_array_2(ctx, v1343);
10034
0
                                                                                                            if v1102.0 == v1345.0 {
10035
0
                                                                                                                if v1102.1 == v1345.1 {
10036
0
                                                                                                                    let v1348 = constructor_spaceship_s(ctx, v91.0, v1102.0, v1102.1);
10037
0
                                                                                                                    let v1349 = constructor_sextend_maybe(ctx, v2.0, v1348);
10038
                                                                                                                    // Rule at src/opts/spaceship.isle line 133.
10039
0
                                                                                                                    returns.extend(Some(v1349));
10040
0
                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
10041
0
                                                                                                                }
10042
0
                                                                                                            }
10043
0
                                                                                                        }
10044
                                                                                                    }
10045
                                                                                                    &IntCC::SignedLessThan => {
10046
0
                                                                                                        if v91.0 == v1339.0 {
10047
0
                                                                                                            let v1102 = C::unpack_value_array_2(ctx, v1100);
10048
0
                                                                                                            let v1345 = C::unpack_value_array_2(ctx, v1343);
10049
0
                                                                                                            if v1102.0 == v1345.0 {
10050
0
                                                                                                                if v1102.1 == v1345.1 {
10051
0
                                                                                                                    let v1348 = constructor_spaceship_s(ctx, v91.0, v1102.0, v1102.1);
10052
0
                                                                                                                    let v1349 = constructor_sextend_maybe(ctx, v2.0, v1348);
10053
                                                                                                                    // Rule at src/opts/spaceship.isle line 123.
10054
0
                                                                                                                    returns.extend(Some(v1349));
10055
0
                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
10056
0
                                                                                                                }
10057
0
                                                                                                            }
10058
0
                                                                                                        }
10059
                                                                                                    }
10060
0
                                                                                                    _ => {}
10061
                                                                                                }
10062
0
                                                                                            }
10063
0
                                                                                        }
10064
                                                                                    }
10065
0
                                                                                }
10066
0
                                                                            }
10067
0
                                                                        }
10068
                                                                    }
10069
0
                                                                }
10070
                                                            }
10071
0
                                                            _ => {}
10072
                                                        }
10073
4
                                                    }
10074
                                                }
10075
4
                                                let v1102 = C::unpack_value_array_2(ctx, v1100);
10076
4
                                                if v86.1 == v1102.0 {
10077
0
                                                    if v86.2 == v1102.1 {
10078
0
                                                        let v1174 = constructor_smax(ctx, v2.0, v1102.0, v1102.1);
10079
                                                        // Rule at src/opts/selects.isle line 25.
10080
0
                                                        returns.extend(Some(v1174));
10081
0
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
10082
0
                                                    }
10083
4
                                                }
10084
4
                                                if v86.2 == v1102.0 {
10085
0
                                                    if v86.1 == v1102.1 {
10086
0
                                                        let v1176 = constructor_smin(ctx, v2.0, v1102.0, v1102.1);
10087
                                                        // Rule at src/opts/selects.isle line 39.
10088
0
                                                        returns.extend(Some(v1176));
10089
0
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
10090
0
                                                    }
10091
4
                                                }
10092
                                            }
10093
                                            &IntCC::SignedGreaterThanOrEqual => {
10094
4
                                                let v1102 = C::unpack_value_array_2(ctx, v1100);
10095
4
                                                if v86.1 == v1102.0 {
10096
0
                                                    if v86.2 == v1102.1 {
10097
0
                                                        let v1174 = constructor_smax(ctx, v2.0, v1102.0, v1102.1);
10098
                                                        // Rule at src/opts/selects.isle line 26.
10099
0
                                                        returns.extend(Some(v1174));
10100
0
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
10101
0
                                                    }
10102
0
                                                    let mut v1115 = C::inst_data_value_etor_returns::default();
10103
0
                                                    C::inst_data_value_etor(ctx, v86.2, &mut v1115);
10104
0
                                                    let mut v1115 = v1115.into_context_iter();
10105
0
                                                    while let Some(v1116) = v1115.next(ctx) {
10106
                                                        if let &InstructionData::Unary {
10107
0
                                                            opcode: ref v1197,
10108
0
                                                            arg: v1198,
10109
0
                                                        } = &v1116.1 {
10110
0
                                                            if let &Opcode::Ineg = v1197 {
10111
0
                                                                if v86.1 == v1198 {
10112
0
                                                                    if v2.0 == v1116.0 {
10113
0
                                                                        let mut v1203 = C::inst_data_value_etor_returns::default();
10114
0
                                                                        C::inst_data_value_etor(ctx, v1102.1, &mut v1203);
10115
0
                                                                        let mut v1203 = v1203.into_context_iter();
10116
0
                                                                        while let Some(v1204) = v1203.next(ctx) {
10117
                                                                            if let &InstructionData::UnaryImm {
10118
0
                                                                                opcode: ref v1207,
10119
0
                                                                                imm: v1208,
10120
0
                                                                            } = &v1204.1 {
10121
0
                                                                                if let &Opcode::Iconst = v1207 {
10122
0
                                                                                    let v1209 = C::u64_from_imm64(ctx, v1208);
10123
0
                                                                                    if v1209 == 0x0_u64 {
10124
0
                                                                                        if v2.0 == v1204.0 {
10125
0
                                                                                            let v1210 = constructor_iabs(ctx, v2.0, v1102.0);
10126
0
                                                                                            let v1211 = C::subsume(ctx, v1210);
10127
                                                                                            // Rule at src/opts/selects.isle line 90.
10128
0
                                                                                            returns.extend(Some(v1211));
10129
0
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
10130
0
                                                                                        }
10131
0
                                                                                    }
10132
0
                                                                                }
10133
0
                                                                            }
10134
                                                                        }
10135
0
                                                                    }
10136
0
                                                                }
10137
0
                                                            }
10138
0
                                                        }
10139
                                                    }
10140
4
                                                }
10141
4
                                                if v86.1 == v1102.1 {
10142
0
                                                    if v86.2 == v1102.0 {
10143
0
                                                        let v1176 = constructor_smin(ctx, v2.0, v1102.0, v1102.1);
10144
                                                        // Rule at src/opts/selects.isle line 40.
10145
0
                                                        returns.extend(Some(v1176));
10146
0
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
10147
0
                                                    }
10148
4
                                                }
10149
                                            }
10150
                                            &IntCC::SignedLessThan => {
10151
418
                                                let v1102 = C::unpack_value_array_2(ctx, v1100);
10152
418
                                                if v86.2 == v1102.0 {
10153
0
                                                    if v86.1 == v1102.1 {
10154
0
                                                        let v1174 = constructor_smax(ctx, v2.0, v1102.0, v1102.1);
10155
                                                        // Rule at src/opts/selects.isle line 35.
10156
0
                                                        returns.extend(Some(v1174));
10157
0
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
10158
0
                                                    }
10159
0
                                                    let mut v96 = C::inst_data_value_etor_returns::default();
10160
0
                                                    C::inst_data_value_etor(ctx, v86.1, &mut v96);
10161
0
                                                    let mut v96 = v96.into_context_iter();
10162
0
                                                    while let Some(v97) = v96.next(ctx) {
10163
                                                        if let &InstructionData::Unary {
10164
0
                                                            opcode: ref v100,
10165
0
                                                            arg: v101,
10166
0
                                                        } = &v97.1 {
10167
0
                                                            if let &Opcode::Ineg = v100 {
10168
0
                                                                if v86.2 == v101 {
10169
0
                                                                    if v2.0 == v97.0 {
10170
0
                                                                        let mut v1203 = C::inst_data_value_etor_returns::default();
10171
0
                                                                        C::inst_data_value_etor(ctx, v1102.1, &mut v1203);
10172
0
                                                                        let mut v1203 = v1203.into_context_iter();
10173
0
                                                                        while let Some(v1204) = v1203.next(ctx) {
10174
                                                                            if let &InstructionData::UnaryImm {
10175
0
                                                                                opcode: ref v1207,
10176
0
                                                                                imm: v1208,
10177
0
                                                                            } = &v1204.1 {
10178
0
                                                                                if let &Opcode::Iconst = v1207 {
10179
0
                                                                                    let v1209 = C::u64_from_imm64(ctx, v1208);
10180
0
                                                                                    if v1209 == 0x0_u64 {
10181
0
                                                                                        if v2.0 == v1204.0 {
10182
0
                                                                                            let v1210 = constructor_iabs(ctx, v2.0, v1102.0);
10183
0
                                                                                            let v1211 = C::subsume(ctx, v1210);
10184
                                                                                            // Rule at src/opts/selects.isle line 92.
10185
0
                                                                                            returns.extend(Some(v1211));
10186
0
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
10187
0
                                                                                        }
10188
0
                                                                                    }
10189
0
                                                                                }
10190
0
                                                                            }
10191
                                                                        }
10192
0
                                                                    }
10193
0
                                                                }
10194
0
                                                            }
10195
0
                                                        }
10196
                                                    }
10197
418
                                                }
10198
418
                                                let mut v1161 = C::inst_data_value_tupled_etor_returns::default();
10199
418
                                                C::inst_data_value_tupled_etor(ctx, v86.1, &mut v1161);
10200
418
                                                let mut v1161 = v1161.into_context_iter();
10201
667
                                                while let Some(
v1162249
) = v1161.next(ctx) {
10202
249
                                                    let v1163 = C::iconst_sextend_etor(ctx, v1162);
10203
249
                                                    if let Some(
v1164166
) = v1163 {
10204
166
                                                        if v1164.1 == -1_i64 {
10205
166
                                                            if v2.0 == v1164.0 {
10206
166
                                                                let mut v1294 = C::uextend_maybe_etor_returns::default();
10207
166
                                                                C::uextend_maybe_etor(ctx, v86.2, &mut v1294);
10208
166
                                                                let mut v1294 = v1294.into_context_iter();
10209
332
                                                                while let Some(
v1295166
) = v1294.next(ctx) {
10210
166
                                                                    if v2.0 == v1295.0 {
10211
166
                                                                        let mut v1298 = C::inst_data_value_etor_returns::default();
10212
166
                                                                        C::inst_data_value_etor(ctx, v1295.1, &mut v1298);
10213
166
                                                                        let mut v1298 = v1298.into_context_iter();
10214
332
                                                                        while let Some(
v1299166
) = v1298.next(ctx) {
10215
                                                                            if let &InstructionData::IntCompare {
10216
132
                                                                                opcode: ref v1302,
10217
132
                                                                                args: ref v1303,
10218
132
                                                                                cond: ref v1304,
10219
166
                                                                            } = &v1299.1 {
10220
132
                                                                                if let &Opcode::Icmp = v1302 {
10221
132
                                                                                    match v1304 {
10222
                                                                                        &IntCC::NotEqual => {
10223
132
                                                                                            if v91.0 == v1299.0 {
10224
132
                                                                                                let v1305 = C::unpack_value_array_2(ctx, v1303);
10225
132
                                                                                                if v1102.0 == v1305.0 {
10226
132
                                                                                                    if v1102.1 == v1305.1 {
10227
132
                                                                                                        let v1348 = constructor_spaceship_s(ctx, v91.0, v1102.0, v1102.1);
10228
132
                                                                                                        let v1349 = constructor_sextend_maybe(ctx, v2.0, v1348);
10229
                                                                                                        // Rule at src/opts/spaceship.isle line 77.
10230
132
                                                                                                        returns.extend(Some(v1349));
10231
132
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
10232
0
                                                                                                    }
10233
0
                                                                                                }
10234
0
                                                                                            }
10235
                                                                                        }
10236
                                                                                        &IntCC::SignedGreaterThan => {
10237
0
                                                                                            if v91.0 == v1299.0 {
10238
0
                                                                                                let v1305 = C::unpack_value_array_2(ctx, v1303);
10239
0
                                                                                                if v1102.0 == v1305.0 {
10240
0
                                                                                                    if v1102.1 == v1305.1 {
10241
0
                                                                                                        let v1348 = constructor_spaceship_s(ctx, v91.0, v1102.0, v1102.1);
10242
0
                                                                                                        let v1349 = constructor_sextend_maybe(ctx, v2.0, v1348);
10243
                                                                                                        // Rule at src/opts/spaceship.isle line 83.
10244
0
                                                                                                        returns.extend(Some(v1349));
10245
0
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
10246
0
                                                                                                    }
10247
0
                                                                                                }
10248
0
                                                                                            }
10249
                                                                                        }
10250
0
                                                                                        _ => {}
10251
                                                                                    }
10252
0
                                                                                }
10253
34
                                                                            }
10254
                                                                        }
10255
0
                                                                    }
10256
                                                                }
10257
0
                                                            }
10258
0
                                                        }
10259
83
                                                    }
10260
                                                }
10261
418
                                                if v86.1 == v1102.0 {
10262
0
                                                    if v86.2 == v1102.1 {
10263
0
                                                        let v1176 = constructor_smin(ctx, v2.0, v1102.0, v1102.1);
10264
                                                        // Rule at src/opts/selects.isle line 29.
10265
0
                                                        returns.extend(Some(v1176));
10266
0
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
10267
0
                                                    }
10268
418
                                                }
10269
                                            }
10270
                                            &IntCC::SignedLessThanOrEqual => {
10271
0
                                                let v1102 = C::unpack_value_array_2(ctx, v1100);
10272
0
                                                if v86.2 == v1102.0 {
10273
0
                                                    if v86.1 == v1102.1 {
10274
0
                                                        let v1174 = constructor_smax(ctx, v2.0, v1102.0, v1102.1);
10275
                                                        // Rule at src/opts/selects.isle line 36.
10276
0
                                                        returns.extend(Some(v1174));
10277
0
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
10278
0
                                                    }
10279
0
                                                    let mut v96 = C::inst_data_value_etor_returns::default();
10280
0
                                                    C::inst_data_value_etor(ctx, v86.1, &mut v96);
10281
0
                                                    let mut v96 = v96.into_context_iter();
10282
0
                                                    while let Some(v97) = v96.next(ctx) {
10283
                                                        if let &InstructionData::Unary {
10284
0
                                                            opcode: ref v100,
10285
0
                                                            arg: v101,
10286
0
                                                        } = &v97.1 {
10287
0
                                                            if let &Opcode::Ineg = v100 {
10288
0
                                                                if v86.2 == v101 {
10289
0
                                                                    if v2.0 == v97.0 {
10290
0
                                                                        let mut v1203 = C::inst_data_value_etor_returns::default();
10291
0
                                                                        C::inst_data_value_etor(ctx, v1102.1, &mut v1203);
10292
0
                                                                        let mut v1203 = v1203.into_context_iter();
10293
0
                                                                        while let Some(v1204) = v1203.next(ctx) {
10294
                                                                            if let &InstructionData::UnaryImm {
10295
0
                                                                                opcode: ref v1207,
10296
0
                                                                                imm: v1208,
10297
0
                                                                            } = &v1204.1 {
10298
0
                                                                                if let &Opcode::Iconst = v1207 {
10299
0
                                                                                    let v1209 = C::u64_from_imm64(ctx, v1208);
10300
0
                                                                                    if v1209 == 0x0_u64 {
10301
0
                                                                                        if v2.0 == v1204.0 {
10302
0
                                                                                            let v1210 = constructor_iabs(ctx, v2.0, v1102.0);
10303
0
                                                                                            let v1211 = C::subsume(ctx, v1210);
10304
                                                                                            // Rule at src/opts/selects.isle line 91.
10305
0
                                                                                            returns.extend(Some(v1211));
10306
0
                                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
10307
0
                                                                                        }
10308
0
                                                                                    }
10309
0
                                                                                }
10310
0
                                                                            }
10311
                                                                        }
10312
0
                                                                    }
10313
0
                                                                }
10314
0
                                                            }
10315
0
                                                        }
10316
                                                    }
10317
0
                                                }
10318
0
                                                if v86.1 == v1102.0 {
10319
0
                                                    if v86.2 == v1102.1 {
10320
0
                                                        let v1176 = constructor_smin(ctx, v2.0, v1102.0, v1102.1);
10321
                                                        // Rule at src/opts/selects.isle line 30.
10322
0
                                                        returns.extend(Some(v1176));
10323
0
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
10324
0
                                                    }
10325
0
                                                }
10326
                                            }
10327
                                            &IntCC::UnsignedGreaterThan => {
10328
7.13k
                                                let mut v1115 = C::inst_data_value_etor_returns::default();
10329
7.13k
                                                C::inst_data_value_etor(ctx, v86.2, &mut v1115);
10330
7.13k
                                                let mut v1115 = v1115.into_context_iter();
10331
13.7k
                                                while let Some(
v11166.57k
) = v1115.next(ctx) {
10332
                                                    if let &InstructionData::Unary {
10333
170
                                                        opcode: ref v1197,
10334
170
                                                        arg: v1198,
10335
6.57k
                                                    } = &v1116.1 {
10336
170
                                                        match v1197 {
10337
                                                            &Opcode::Ineg => {
10338
21
                                                                if v91.0 == v1116.0 {
10339
0
                                                                    let mut v1161 = C::inst_data_value_tupled_etor_returns::default();
10340
0
                                                                    C::inst_data_value_tupled_etor(ctx, v86.1, &mut v1161);
10341
0
                                                                    let mut v1161 = v1161.into_context_iter();
10342
0
                                                                    while let Some(v1162) = v1161.next(ctx) {
10343
0
                                                                        let v1163 = C::iconst_sextend_etor(ctx, v1162);
10344
0
                                                                        if let Some(v1164) = v1163 {
10345
0
                                                                            if v1164.1 == 1_i64 {
10346
0
                                                                                if v2.0 == v1164.0 {
10347
0
                                                                                    let mut v1338 = C::inst_data_value_etor_returns::default();
10348
0
                                                                                    C::inst_data_value_etor(ctx, v1198, &mut v1338);
10349
0
                                                                                    let mut v1338 = v1338.into_context_iter();
10350
0
                                                                                    while let Some(v1339) = v1338.next(ctx) {
10351
                                                                                        if let &InstructionData::IntCompare {
10352
0
                                                                                            opcode: ref v1342,
10353
0
                                                                                            args: ref v1343,
10354
0
                                                                                            cond: ref v1344,
10355
0
                                                                                        } = &v1339.1 {
10356
0
                                                                                            if let &Opcode::Icmp = v1342 {
10357
0
                                                                                                match v1344 {
10358
                                                                                                    &IntCC::NotEqual => {
10359
0
                                                                                                        if v91.0 == v1339.0 {
10360
0
                                                                                                            let v1102 = C::unpack_value_array_2(ctx, v1100);
10361
0
                                                                                                            let v1345 = C::unpack_value_array_2(ctx, v1343);
10362
0
                                                                                                            if v1102.0 == v1345.0 {
10363
0
                                                                                                                if v1102.1 == v1345.1 {
10364
0
                                                                                                                    let v1308 = constructor_spaceship_u(ctx, v91.0, v1102.0, v1102.1);
10365
0
                                                                                                                    let v1309 = constructor_sextend_maybe(ctx, v2.0, v1308);
10366
                                                                                                                    // Rule at src/opts/spaceship.isle line 64.
10367
0
                                                                                                                    returns.extend(Some(v1309));
10368
0
                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
10369
0
                                                                                                                }
10370
0
                                                                                                            }
10371
0
                                                                                                        }
10372
                                                                                                    }
10373
                                                                                                    &IntCC::UnsignedLessThan => {
10374
0
                                                                                                        if v91.0 == v1339.0 {
10375
0
                                                                                                            let v1102 = C::unpack_value_array_2(ctx, v1100);
10376
0
                                                                                                            let v1345 = C::unpack_value_array_2(ctx, v1343);
10377
0
                                                                                                            if v1102.0 == v1345.0 {
10378
0
                                                                                                                if v1102.1 == v1345.1 {
10379
0
                                                                                                                    let v1308 = constructor_spaceship_u(ctx, v91.0, v1102.0, v1102.1);
10380
0
                                                                                                                    let v1309 = constructor_sextend_maybe(ctx, v2.0, v1308);
10381
                                                                                                                    // Rule at src/opts/spaceship.isle line 54.
10382
0
                                                                                                                    returns.extend(Some(v1309));
10383
0
                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
10384
0
                                                                                                                }
10385
0
                                                                                                            }
10386
0
                                                                                                        }
10387
                                                                                                    }
10388
0
                                                                                                    _ => {}
10389
                                                                                                }
10390
0
                                                                                            }
10391
0
                                                                                        }
10392
                                                                                    }
10393
0
                                                                                }
10394
0
                                                                            }
10395
0
                                                                        }
10396
                                                                    }
10397
21
                                                                }
10398
                                                            }
10399
                                                            &Opcode::Bmask => {
10400
0
                                                                if v2.0 == v1116.0 {
10401
0
                                                                    let mut v1161 = C::inst_data_value_tupled_etor_returns::default();
10402
0
                                                                    C::inst_data_value_tupled_etor(ctx, v86.1, &mut v1161);
10403
0
                                                                    let mut v1161 = v1161.into_context_iter();
10404
0
                                                                    while let Some(v1162) = v1161.next(ctx) {
10405
0
                                                                        let v1163 = C::iconst_sextend_etor(ctx, v1162);
10406
0
                                                                        if let Some(v1164) = v1163 {
10407
0
                                                                            if v1164.1 == 1_i64 {
10408
0
                                                                                if v2.0 == v1164.0 {
10409
0
                                                                                    let mut v1338 = C::inst_data_value_etor_returns::default();
10410
0
                                                                                    C::inst_data_value_etor(ctx, v1198, &mut v1338);
10411
0
                                                                                    let mut v1338 = v1338.into_context_iter();
10412
0
                                                                                    while let Some(v1339) = v1338.next(ctx) {
10413
                                                                                        if let &InstructionData::IntCompare {
10414
0
                                                                                            opcode: ref v1342,
10415
0
                                                                                            args: ref v1343,
10416
0
                                                                                            cond: ref v1344,
10417
0
                                                                                        } = &v1339.1 {
10418
0
                                                                                            if let &Opcode::Icmp = v1342 {
10419
0
                                                                                                match v1344 {
10420
                                                                                                    &IntCC::NotEqual => {
10421
0
                                                                                                        if v91.0 == v1339.0 {
10422
0
                                                                                                            let v1102 = C::unpack_value_array_2(ctx, v1100);
10423
0
                                                                                                            let v1345 = C::unpack_value_array_2(ctx, v1343);
10424
0
                                                                                                            if v1102.0 == v1345.0 {
10425
0
                                                                                                                if v1102.1 == v1345.1 {
10426
0
                                                                                                                    let v1308 = constructor_spaceship_u(ctx, v91.0, v1102.0, v1102.1);
10427
0
                                                                                                                    let v1309 = constructor_sextend_maybe(ctx, v2.0, v1308);
10428
                                                                                                                    // Rule at src/opts/spaceship.isle line 68.
10429
0
                                                                                                                    returns.extend(Some(v1309));
10430
0
                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
10431
0
                                                                                                                }
10432
0
                                                                                                            }
10433
0
                                                                                                        }
10434
                                                                                                    }
10435
                                                                                                    &IntCC::UnsignedLessThan => {
10436
0
                                                                                                        if v91.0 == v1339.0 {
10437
0
                                                                                                            let v1102 = C::unpack_value_array_2(ctx, v1100);
10438
0
                                                                                                            let v1345 = C::unpack_value_array_2(ctx, v1343);
10439
0
                                                                                                            if v1102.0 == v1345.0 {
10440
0
                                                                                                                if v1102.1 == v1345.1 {
10441
0
                                                                                                                    let v1308 = constructor_spaceship_u(ctx, v91.0, v1102.0, v1102.1);
10442
0
                                                                                                                    let v1309 = constructor_sextend_maybe(ctx, v2.0, v1308);
10443
                                                                                                                    // Rule at src/opts/spaceship.isle line 58.
10444
0
                                                                                                                    returns.extend(Some(v1309));
10445
0
                                                                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
10446
0
                                                                                                                }
10447
0
                                                                                                            }
10448
0
                                                                                                        }
10449
                                                                                                    }
10450
0
                                                                                                    _ => {}
10451
                                                                                                }
10452
0
                                                                                            }
10453
0
                                                                                        }
10454
                                                                                    }
10455
0
                                                                                }
10456
0
                                                                            }
10457
0
                                                                        }
10458
                                                                    }
10459
0
                                                                }
10460
                                                            }
10461
149
                                                            _ => {}
10462
                                                        }
10463
6.40k
                                                    }
10464
                                                }
10465
7.13k
                                                let v1102 = C::unpack_value_array_2(ctx, v1100);
10466
7.13k
                                                if v86.1 == v1102.0 {
10467
2.82k
                                                    if v86.2 == v1102.1 {
10468
2.80k
                                                        let v1175 = constructor_umax(ctx, v2.0, v1102.0, v1102.1);
10469
                                                        // Rule at src/opts/selects.isle line 27.
10470
2.80k
                                                        returns.extend(Some(v1175));
10471
2.80k
                                                        if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
10472
26
                                                    }
10473
4.31k
                                                }
10474
7.13k
                                                if v86.2 == v1102.0 {
10475
1.79k
                                                    if v86.1 == v1102.1 {
10476
852
                                                        let v1177 = constructor_umin(ctx, v2.0, v1102.0, v1102.1);
10477
                                                        // Rule at src/opts/selects.isle line 41.
10478
852
                                                        returns.extend(Some(v1177));
10479
852
                                                        if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
10480
945
                                                    }
10481
5.33k
                                                }
10482
                                            }
10483
                                            &IntCC::UnsignedGreaterThanOrEqual => {
10484
38
                                                let v1102 = C::unpack_value_array_2(ctx, v1100);
10485
38
                                                if v86.1 == v1102.0 {
10486
0
                                                    if v86.2 == v1102.1 {
10487
0
                                                        let v1175 = constructor_umax(ctx, v2.0, v1102.0, v1102.1);
10488
                                                        // Rule at src/opts/selects.isle line 28.
10489
0
                                                        returns.extend(Some(v1175));
10490
0
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
10491
0
                                                    }
10492
38
                                                }
10493
38
                                                if v86.1 == v1102.1 {
10494
0
                                                    if v86.2 == v1102.0 {
10495
0
                                                        let v1177 = constructor_umin(ctx, v2.0, v1102.0, v1102.1);
10496
                                                        // Rule at src/opts/selects.isle line 42.
10497
0
                                                        returns.extend(Some(v1177));
10498
0
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
10499
0
                                                    }
10500
38
                                                }
10501
                                            }
10502
                                            &IntCC::UnsignedLessThan => {
10503
6.37k
                                                let mut v1161 = C::inst_data_value_tupled_etor_returns::default();
10504
6.37k
                                                C::inst_data_value_tupled_etor(ctx, v86.1, &mut v1161);
10505
6.37k
                                                let mut v1161 = v1161.into_context_iter();
10506
12.6k
                                                while let Some(
v11626.30k
) = v1161.next(ctx) {
10507
6.30k
                                                    let v1163 = C::iconst_sextend_etor(ctx, v1162);
10508
6.30k
                                                    if let Some(
v11645.05k
) = v1163 {
10509
5.05k
                                                        if v1164.1 == -1_i64 {
10510
4.24k
                                                            if v2.0 == v1164.0 {
10511
4.24k
                                                                let mut v1294 = C::uextend_maybe_etor_returns::default();
10512
4.24k
                                                                C::uextend_maybe_etor(ctx, v86.2, &mut v1294);
10513
4.24k
                                                                let mut v1294 = v1294.into_context_iter();
10514
8.48k
                                                                while let Some(
v12954.24k
) = v1294.next(ctx) {
10515
4.24k
                                                                    if v2.0 == v1295.0 {
10516
4.24k
                                                                        let mut v1298 = C::inst_data_value_etor_returns::default();
10517
4.24k
                                                                        C::inst_data_value_etor(ctx, v1295.1, &mut v1298);
10518
4.24k
                                                                        let mut v1298 = v1298.into_context_iter();
10519
8.38k
                                                                        while let Some(
v12994.14k
) = v1298.next(ctx) {
10520
                                                                            if let &InstructionData::IntCompare {
10521
382
                                                                                opcode: ref v1302,
10522
382
                                                                                args: ref v1303,
10523
382
                                                                                cond: ref v1304,
10524
4.14k
                                                                            } = &v1299.1 {
10525
382
                                                                                if let &Opcode::Icmp = v1302 {
10526
382
                                                                                    match v1304 {
10527
                                                                                        &IntCC::NotEqual => {
10528
382
                                                                                            if v91.0 == v1299.0 {
10529
382
                                                                                                let v1102 = C::unpack_value_array_2(ctx, v1100);
10530
382
                                                                                                let v1305 = C::unpack_value_array_2(ctx, v1303);
10531
382
                                                                                                if v1102.0 == v1305.0 {
10532
207
                                                                                                    if v1102.1 == v1305.1 {
10533
207
                                                                                                        let v1308 = constructor_spaceship_u(ctx, v91.0, v1102.0, v1102.1);
10534
207
                                                                                                        let v1309 = constructor_sextend_maybe(ctx, v2.0, v1308);
10535
                                                                                                        // Rule at src/opts/spaceship.isle line 12.
10536
207
                                                                                                        returns.extend(Some(v1309));
10537
207
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
10538
0
                                                                                                    }
10539
175
                                                                                                }
10540
0
                                                                                            }
10541
                                                                                        }
10542
                                                                                        &IntCC::UnsignedGreaterThan => {
10543
0
                                                                                            if v91.0 == v1299.0 {
10544
0
                                                                                                let v1102 = C::unpack_value_array_2(ctx, v1100);
10545
0
                                                                                                let v1305 = C::unpack_value_array_2(ctx, v1303);
10546
0
                                                                                                if v1102.0 == v1305.0 {
10547
0
                                                                                                    if v1102.1 == v1305.1 {
10548
0
                                                                                                        let v1308 = constructor_spaceship_u(ctx, v91.0, v1102.0, v1102.1);
10549
0
                                                                                                        let v1309 = constructor_sextend_maybe(ctx, v2.0, v1308);
10550
                                                                                                        // Rule at src/opts/spaceship.isle line 18.
10551
0
                                                                                                        returns.extend(Some(v1309));
10552
0
                                                                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
10553
0
                                                                                                    }
10554
0
                                                                                                }
10555
0
                                                                                            }
10556
                                                                                        }
10557
0
                                                                                        _ => {}
10558
                                                                                    }
10559
0
                                                                                }
10560
3.76k
                                                                            }
10561
                                                                        }
10562
0
                                                                    }
10563
                                                                }
10564
0
                                                            }
10565
811
                                                        }
10566
1.24k
                                                    }
10567
                                                }
10568
6.37k
                                                let v1102 = C::unpack_value_array_2(ctx, v1100);
10569
6.37k
                                                if v86.1 == v1102.0 {
10570
807
                                                    if v86.2 == v1102.1 {
10571
757
                                                        let v1177 = constructor_umin(ctx, v2.0, v1102.0, v1102.1);
10572
                                                        // Rule at src/opts/selects.isle line 31.
10573
757
                                                        returns.extend(Some(v1177));
10574
757
                                                        if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
10575
50
                                                    }
10576
5.57k
                                                }
10577
6.37k
                                                if v86.1 == v1102.1 {
10578
23
                                                    if v86.2 == v1102.0 {
10579
16
                                                        let v1175 = constructor_umax(ctx, v2.0, v1102.0, v1102.1);
10580
                                                        // Rule at src/opts/selects.isle line 37.
10581
16
                                                        returns.extend(Some(v1175));
10582
16
                                                        if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
10583
7
                                                    }
10584
6.35k
                                                }
10585
                                            }
10586
                                            &IntCC::UnsignedLessThanOrEqual => {
10587
0
                                                let v1102 = C::unpack_value_array_2(ctx, v1100);
10588
0
                                                if v86.1 == v1102.0 {
10589
0
                                                    if v86.2 == v1102.1 {
10590
0
                                                        let v1177 = constructor_umin(ctx, v2.0, v1102.0, v1102.1);
10591
                                                        // Rule at src/opts/selects.isle line 32.
10592
0
                                                        returns.extend(Some(v1177));
10593
0
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
10594
0
                                                    }
10595
0
                                                }
10596
0
                                                if v86.1 == v1102.1 {
10597
0
                                                    if v86.2 == v1102.0 {
10598
0
                                                        let v1175 = constructor_umax(ctx, v2.0, v1102.0, v1102.1);
10599
                                                        // Rule at src/opts/selects.isle line 38.
10600
0
                                                        returns.extend(Some(v1175));
10601
0
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
10602
0
                                                    }
10603
0
                                                }
10604
                                            }
10605
166
                                            _ => {}
10606
                                        }
10607
24.6k
                                        let mut v96 = C::inst_data_value_etor_returns::default();
10608
24.6k
                                        C::inst_data_value_etor(ctx, v86.1, &mut v96);
10609
24.6k
                                        let mut v96 = v96.into_context_iter();
10610
50.7k
                                        while let Some(
v9726.0k
) = v96.next(ctx) {
10611
                                            if let &InstructionData::UnaryImm {
10612
8.54k
                                                opcode: ref v1149,
10613
8.54k
                                                imm: v1150,
10614
26.0k
                                            } = &v97.1 {
10615
8.54k
                                                if let &Opcode::Iconst = v1149 {
10616
8.54k
                                                    let v1151 = C::u64_from_imm64(ctx, v1150);
10617
8.54k
                                                    match v1151 {
10618
                                                        0x0_u64 => {
10619
2.44k
                                                            let mut v1115 = C::inst_data_value_etor_returns::default();
10620
2.44k
                                                            C::inst_data_value_etor(ctx, v86.2, &mut v1115);
10621
2.44k
                                                            let mut v1115 = v1115.into_context_iter();
10622
4.98k
                                                            while let Some(
v11162.53k
) = v1115.next(ctx) {
10623
                                                                if let &InstructionData::UnaryImm {
10624
6
                                                                    opcode: ref v1152,
10625
6
                                                                    imm: v1153,
10626
2.53k
                                                                } = &v1116.1 {
10627
6
                                                                    if let &Opcode::Iconst = v1152 {
10628
6
                                                                        let v1154 = C::u64_from_imm64(ctx, v1153);
10629
6
                                                                        let v1155 = C::u64_matches_non_zero(ctx, v1154);
10630
6
                                                                        if let Some(v1156) = v1155 {
10631
6
                                                                            if v1156 == true {
10632
6
                                                                                let v1157 = &C::intcc_complement(ctx, v1101);
10633
6
                                                                                let v1102 = C::unpack_value_array_2(ctx, v1100);
10634
6
                                                                                let v1158 = constructor_icmp(ctx, v91.0, v1157, v1102.0, v1102.1);
10635
6
                                                                                let v1159 = constructor_select(ctx, v2.0, v1158, v86.2, v86.1);
10636
                                                                                // Rule at src/opts/selects.isle line 8.
10637
6
                                                                                returns.extend(Some(v1159));
10638
6
                                                                                if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
10639
0
                                                                            }
10640
0
                                                                        }
10641
0
                                                                    }
10642
2.52k
                                                                }
10643
                                                            }
10644
                                                        }
10645
                                                        0x1_u64 => {
10646
165
                                                            let mut v1115 = C::inst_data_value_etor_returns::default();
10647
165
                                                            C::inst_data_value_etor(ctx, v86.2, &mut v1115);
10648
165
                                                            let mut v1115 = v1115.into_context_iter();
10649
332
                                                            while let Some(
v1116167
) = v1115.next(ctx) {
10650
                                                                if let &InstructionData::UnaryImm {
10651
43
                                                                    opcode: ref v1152,
10652
43
                                                                    imm: v1153,
10653
167
                                                                } = &v1116.1 {
10654
43
                                                                    if let &Opcode::Iconst = v1152 {
10655
43
                                                                        let v1154 = C::u64_from_imm64(ctx, v1153);
10656
43
                                                                        if v1154 == 0x0_u64 {
10657
0
                                                                            let v1160 = constructor_uextend_maybe(ctx, v2.0, v86.0);
10658
                                                                            // Rule at src/opts/selects.isle line 14.
10659
0
                                                                            returns.extend(Some(v1160));
10660
0
                                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
10661
43
                                                                        }
10662
0
                                                                    }
10663
124
                                                                }
10664
                                                            }
10665
                                                        }
10666
5.93k
                                                        _ => {}
10667
                                                    }
10668
0
                                                }
10669
17.4k
                                            }
10670
                                        }
10671
24.6k
                                        let mut v1161 = C::inst_data_value_tupled_etor_returns::default();
10672
24.6k
                                        C::inst_data_value_tupled_etor(ctx, v86.1, &mut v1161);
10673
24.6k
                                        let mut v1161 = v1161.into_context_iter();
10674
50.7k
                                        while let Some(
v116226.0k
) = v1161.next(ctx) {
10675
26.0k
                                            let v1163 = C::iconst_sextend_etor(ctx, v1162);
10676
26.0k
                                            if let Some(
v11648.54k
) = v1163 {
10677
8.54k
                                                if v1164.1 == -1_i64 {
10678
4.67k
                                                    let mut v1167 = C::inst_data_value_tupled_etor_returns::default();
10679
4.67k
                                                    C::inst_data_value_tupled_etor(ctx, v86.2, &mut v1167);
10680
4.67k
                                                    let mut v1167 = v1167.into_context_iter();
10681
9.26k
                                                    while let Some(
v11684.58k
) = v1167.next(ctx) {
10682
4.58k
                                                        let v1169 = C::iconst_sextend_etor(ctx, v1168);
10683
4.58k
                                                        if let Some(
v1170116
) = v1169 {
10684
116
                                                            if v1170.1 == 0_i64 {
10685
8
                                                                let v1173 = constructor_bmask(ctx, v2.0, v86.0);
10686
                                                                // Rule at src/opts/selects.isle line 19.
10687
8
                                                                returns.extend(Some(v1173));
10688
8
                                                                if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
10689
108
                                                            }
10690
4.47k
                                                        }
10691
                                                    }
10692
3.87k
                                                }
10693
17.4k
                                            }
10694
                                        }
10695
0
                                    }
10696
                                }
10697
                                &InstructionData::Unary {
10698
25.9k
                                    opcode: ref v94,
10699
25.9k
                                    arg: v95,
10700
                                } => {
10701
25.9k
                                    if let &Opcode::Uextend = v94 {
10702
25.8k
                                        let mut v1036 = C::inst_data_value_etor_returns::default();
10703
25.8k
                                        C::inst_data_value_etor(ctx, v95, &mut v1036);
10704
25.8k
                                        let mut v1036 = v1036.into_context_iter();
10705
59.0k
                                        while let Some(
v103733.2k
) = v1036.next(ctx) {
10706
                                            if let &InstructionData::IntCompare {
10707
24.6k
                                                opcode: ref v1040,
10708
24.6k
                                                args: ref v1041,
10709
24.6k
                                                cond: ref v1042,
10710
33.2k
                                            } = &v1037.1 {
10711
24.6k
                                                if let &Opcode::Icmp = v1040 {
10712
24.6k
                                                    let v1046 = constructor_select(ctx, v2.0, v95, v86.1, v86.2);
10713
                                                    // Rule at src/opts/icmp.isle line 76.
10714
24.6k
                                                    returns.extend(Some(v1046));
10715
24.6k
                                                    if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
10716
                                                    // Rule at src/opts/icmp.isle line 79.
10717
24.6k
                                                    returns.extend(Some(v1046));
10718
24.6k
                                                    if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
10719
0
                                                }
10720
8.55k
                                            }
10721
                                        }
10722
114
                                    }
10723
                                }
10724
                                &InstructionData::UnaryImm {
10725
18
                                    opcode: ref v646,
10726
18
                                    imm: v647,
10727
                                } => {
10728
18
                                    if let &Opcode::Iconst = v646 {
10729
18
                                        let v648 = C::u64_from_imm64(ctx, v647);
10730
18
                                        if v648 == 0x0_u64 {
10731
17
                                            let v652 = C::subsume(ctx, v86.2);
10732
                                            // Rule at src/opts/cprop.isle line 169.
10733
17
                                            returns.extend(Some(v652));
10734
17
                                            if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
10735
1
                                        }
10736
18
                                        let v649 = C::u64_matches_non_zero(ctx, v648);
10737
18
                                        if let Some(v650) = v649 {
10738
18
                                            if v650 == true {
10739
1
                                                let v651 = C::subsume(ctx, v86.1);
10740
                                                // Rule at src/opts/cprop.isle line 167.
10741
1
                                                returns.extend(Some(v651));
10742
1
                                                if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
10743
17
                                            }
10744
0
                                        }
10745
0
                                    }
10746
                                }
10747
19.1k
                                _ => {}
10748
                            }
10749
                        }
10750
54.9k
                        let mut v96 = C::inst_data_value_etor_returns::default();
10751
54.9k
                        C::inst_data_value_etor(ctx, v86.1, &mut v96);
10752
54.9k
                        let mut v96 = v96.into_context_iter();
10753
112k
                        while let Some(
v9757.0k
) = v96.next(ctx) {
10754
                            if let &InstructionData::Unary {
10755
6.28k
                                opcode: ref v100,
10756
6.28k
                                arg: v101,
10757
57.0k
                            } = &v97.1 {
10758
6.28k
                                match v100 {
10759
                                    &Opcode::Uextend => {
10760
5.98k
                                        if v2.0 == v97.0 {
10761
5.98k
                                            let mut v1115 = C::inst_data_value_etor_returns::default();
10762
5.98k
                                            C::inst_data_value_etor(ctx, v86.2, &mut v1115);
10763
5.98k
                                            let mut v1115 = v1115.into_context_iter();
10764
12.0k
                                            while let Some(
v11166.03k
) = v1115.next(ctx) {
10765
                                                if let &InstructionData::Unary {
10766
5.05k
                                                    opcode: ref v1197,
10767
5.05k
                                                    arg: v1198,
10768
6.03k
                                                } = &v1116.1 {
10769
5.05k
                                                    if let &Opcode::Uextend = v1197 {
10770
5.05k
                                                        if v2.0 == v1116.0 {
10771
5.05k
                                                            let v1196 = C::value_type(ctx, v101);
10772
5.05k
                                                            let v1199 = C::value_type(ctx, v1198);
10773
5.05k
                                                            if v1196 == v1199 {
10774
5.05k
                                                                let v1200 = constructor_select(ctx, v1196, v86.0, v101, v1198);
10775
5.05k
                                                                let v1201 = constructor_uextend(ctx, v2.0, v1200);
10776
                                                                // Rule at src/opts/selects.isle line 80.
10777
5.05k
                                                                returns.extend(Some(v1201));
10778
5.05k
                                                                if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
10779
0
                                                            }
10780
0
                                                        }
10781
0
                                                    }
10782
981
                                                }
10783
                                            }
10784
0
                                        }
10785
                                    }
10786
                                    &Opcode::Sextend => {
10787
54
                                        if v2.0 == v97.0 {
10788
54
                                            let mut v1115 = C::inst_data_value_etor_returns::default();
10789
54
                                            C::inst_data_value_etor(ctx, v86.2, &mut v1115);
10790
54
                                            let mut v1115 = v1115.into_context_iter();
10791
216
                                            while let Some(
v1116162
) = v1115.next(ctx) {
10792
                                                if let &InstructionData::Unary {
10793
54
                                                    opcode: ref v1197,
10794
54
                                                    arg: v1198,
10795
162
                                                } = &v1116.1 {
10796
54
                                                    if let &Opcode::Sextend = v1197 {
10797
54
                                                        if v2.0 == v1116.0 {
10798
54
                                                            let v1196 = C::value_type(ctx, v101);
10799
54
                                                            let v1199 = C::value_type(ctx, v1198);
10800
54
                                                            if v1196 == v1199 {
10801
54
                                                                let v1200 = constructor_select(ctx, v1196, v86.0, v101, v1198);
10802
54
                                                                let v1202 = constructor_sextend(ctx, v2.0, v1200);
10803
                                                                // Rule at src/opts/selects.isle line 84.
10804
54
                                                                returns.extend(Some(v1202));
10805
54
                                                                if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
10806
0
                                                            }
10807
0
                                                        }
10808
0
                                                    }
10809
108
                                                }
10810
                                            }
10811
0
                                        }
10812
                                    }
10813
240
                                    _ => {}
10814
                                }
10815
50.7k
                            }
10816
                        }
10817
54.9k
                        if v86.1 == v86.2 {
10818
0
                            let v651 = C::subsume(ctx, v86.1);
10819
                            // Rule at src/opts/selects.isle line 3.
10820
0
                            returns.extend(Some(v651));
10821
0
                            if returns.len() >= MAX_ISLE_RETURNS { return; }
10822
54.9k
                        }
10823
54.9k
                        let mut v265 = ContextIterWrapper::<ConstructorVec<_>, _>::default();
10824
54.9k
                        constructor_truthy(ctx, v86.0, &mut v265);
10825
54.9k
                        let mut v265 = v265.into_context_iter();
10826
80.9k
                        while let Some(
v26626.0k
) = v265.next(ctx) {
10827
26.0k
                            let v267 = constructor_select(ctx, v2.0, v266, v86.1, v86.2);
10828
                            // Rule at src/opts/bitops.isle line 120.
10829
26.0k
                            returns.extend(Some(v267));
10830
26.0k
                            if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
10831
                        }
10832
                    }
10833
                    &Opcode::SelectSpectreGuard => {
10834
29.8k
                        let v86 = C::unpack_value_array_3(ctx, v85);
10835
29.8k
                        let mut v90 = C::inst_data_value_etor_returns::default();
10836
29.8k
                        C::inst_data_value_etor(ctx, v86.0, &mut v90);
10837
29.8k
                        let mut v90 = v90.into_context_iter();
10838
59.6k
                        while let Some(
v9129.8k
) = v90.next(ctx) {
10839
                            if let &InstructionData::UnaryImm {
10840
1
                                opcode: ref v646,
10841
1
                                imm: v647,
10842
29.8k
                            } = &v91.1 {
10843
1
                                if let &Opcode::Iconst = v646 {
10844
1
                                    let v648 = C::u64_from_imm64(ctx, v647);
10845
1
                                    if v648 == 0x0_u64 {
10846
1
                                        let v652 = C::subsume(ctx, v86.2);
10847
                                        // Rule at src/opts/spectre.isle line 13.
10848
1
                                        returns.extend(Some(v652));
10849
1
                                        if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
10850
0
                                    }
10851
1
                                    let v649 = C::u64_matches_non_zero(ctx, v648);
10852
1
                                    if let Some(v650) = v649 {
10853
1
                                        if v650 == true {
10854
0
                                            let v651 = C::subsume(ctx, v86.1);
10855
                                            // Rule at src/opts/spectre.isle line 11.
10856
0
                                            returns.extend(Some(v651));
10857
0
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
10858
1
                                        }
10859
0
                                    }
10860
0
                                }
10861
29.8k
                            }
10862
                        }
10863
29.8k
                        if v86.1 == v86.2 {
10864
0
                            let v651 = C::subsume(ctx, v86.1);
10865
                            // Rule at src/opts/spectre.isle line 9.
10866
0
                            returns.extend(Some(v651));
10867
0
                            if returns.len() >= MAX_ISLE_RETURNS { return; }
10868
29.8k
                        }
10869
                    }
10870
                    &Opcode::Bitselect => {
10871
0
                        let v1178 = C::multi_lane(ctx, v2.0);
10872
0
                        if let Some(v1179) = v1178 {
10873
0
                            let v86 = C::unpack_value_array_3(ctx, v85);
10874
0
                            let mut v90 = C::inst_data_value_etor_returns::default();
10875
0
                            C::inst_data_value_etor(ctx, v86.0, &mut v90);
10876
0
                            let mut v90 = v90.into_context_iter();
10877
0
                            while let Some(v91) = v90.next(ctx) {
10878
                                if let &InstructionData::IntCompare {
10879
0
                                    opcode: ref v1099,
10880
0
                                    args: ref v1100,
10881
0
                                    cond: ref v1101,
10882
0
                                } = &v91.1 {
10883
0
                                    if let &Opcode::Icmp = v1099 {
10884
0
                                        match v1101 {
10885
                                            &IntCC::SignedGreaterThan => {
10886
0
                                                let v1102 = C::unpack_value_array_2(ctx, v1100);
10887
0
                                                if v86.1 == v1102.0 {
10888
0
                                                    if v86.2 == v1102.1 {
10889
0
                                                        let v1174 = constructor_smax(ctx, v2.0, v1102.0, v1102.1);
10890
                                                        // Rule at src/opts/selects.isle line 45.
10891
0
                                                        returns.extend(Some(v1174));
10892
0
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
10893
0
                                                    }
10894
0
                                                }
10895
0
                                                if v86.1 == v1102.1 {
10896
0
                                                    if v86.2 == v1102.0 {
10897
0
                                                        let v1176 = constructor_smin(ctx, v2.0, v1102.0, v1102.1);
10898
                                                        // Rule at src/opts/selects.isle line 59.
10899
0
                                                        returns.extend(Some(v1176));
10900
0
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
10901
0
                                                    }
10902
0
                                                }
10903
                                            }
10904
                                            &IntCC::SignedGreaterThanOrEqual => {
10905
0
                                                let v1102 = C::unpack_value_array_2(ctx, v1100);
10906
0
                                                if v86.1 == v1102.0 {
10907
0
                                                    if v86.2 == v1102.1 {
10908
0
                                                        let v1174 = constructor_smax(ctx, v2.0, v1102.0, v1102.1);
10909
                                                        // Rule at src/opts/selects.isle line 46.
10910
0
                                                        returns.extend(Some(v1174));
10911
0
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
10912
0
                                                    }
10913
0
                                                }
10914
0
                                                if v86.1 == v1102.1 {
10915
0
                                                    if v86.2 == v1102.0 {
10916
0
                                                        let v1176 = constructor_smin(ctx, v2.0, v1102.0, v1102.1);
10917
                                                        // Rule at src/opts/selects.isle line 60.
10918
0
                                                        returns.extend(Some(v1176));
10919
0
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
10920
0
                                                    }
10921
0
                                                }
10922
                                            }
10923
                                            &IntCC::SignedLessThan => {
10924
0
                                                let v1102 = C::unpack_value_array_2(ctx, v1100);
10925
0
                                                if v86.1 == v1102.0 {
10926
0
                                                    if v86.2 == v1102.1 {
10927
0
                                                        let v1176 = constructor_smin(ctx, v2.0, v1102.0, v1102.1);
10928
                                                        // Rule at src/opts/selects.isle line 49.
10929
0
                                                        returns.extend(Some(v1176));
10930
0
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
10931
0
                                                    }
10932
0
                                                }
10933
0
                                                if v86.1 == v1102.1 {
10934
0
                                                    if v86.2 == v1102.0 {
10935
0
                                                        let v1174 = constructor_smax(ctx, v2.0, v1102.0, v1102.1);
10936
                                                        // Rule at src/opts/selects.isle line 55.
10937
0
                                                        returns.extend(Some(v1174));
10938
0
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
10939
0
                                                    }
10940
0
                                                }
10941
                                            }
10942
                                            &IntCC::SignedLessThanOrEqual => {
10943
0
                                                let v1102 = C::unpack_value_array_2(ctx, v1100);
10944
0
                                                if v86.1 == v1102.0 {
10945
0
                                                    if v86.2 == v1102.1 {
10946
0
                                                        let v1176 = constructor_smin(ctx, v2.0, v1102.0, v1102.1);
10947
                                                        // Rule at src/opts/selects.isle line 50.
10948
0
                                                        returns.extend(Some(v1176));
10949
0
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
10950
0
                                                    }
10951
0
                                                }
10952
0
                                                if v86.1 == v1102.1 {
10953
0
                                                    if v86.2 == v1102.0 {
10954
0
                                                        let v1174 = constructor_smax(ctx, v2.0, v1102.0, v1102.1);
10955
                                                        // Rule at src/opts/selects.isle line 56.
10956
0
                                                        returns.extend(Some(v1174));
10957
0
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
10958
0
                                                    }
10959
0
                                                }
10960
                                            }
10961
                                            &IntCC::UnsignedGreaterThan => {
10962
0
                                                let v1102 = C::unpack_value_array_2(ctx, v1100);
10963
0
                                                if v86.1 == v1102.0 {
10964
0
                                                    if v86.2 == v1102.1 {
10965
0
                                                        let v1175 = constructor_umax(ctx, v2.0, v1102.0, v1102.1);
10966
                                                        // Rule at src/opts/selects.isle line 47.
10967
0
                                                        returns.extend(Some(v1175));
10968
0
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
10969
0
                                                    }
10970
0
                                                }
10971
0
                                                if v86.1 == v1102.1 {
10972
0
                                                    if v86.2 == v1102.0 {
10973
0
                                                        let v1177 = constructor_umin(ctx, v2.0, v1102.0, v1102.1);
10974
                                                        // Rule at src/opts/selects.isle line 61.
10975
0
                                                        returns.extend(Some(v1177));
10976
0
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
10977
0
                                                    }
10978
0
                                                }
10979
                                            }
10980
                                            &IntCC::UnsignedGreaterThanOrEqual => {
10981
0
                                                let v1102 = C::unpack_value_array_2(ctx, v1100);
10982
0
                                                if v86.1 == v1102.0 {
10983
0
                                                    if v86.2 == v1102.1 {
10984
0
                                                        let v1175 = constructor_umax(ctx, v2.0, v1102.0, v1102.1);
10985
                                                        // Rule at src/opts/selects.isle line 48.
10986
0
                                                        returns.extend(Some(v1175));
10987
0
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
10988
0
                                                    }
10989
0
                                                }
10990
0
                                                if v86.1 == v1102.1 {
10991
0
                                                    if v86.2 == v1102.0 {
10992
0
                                                        let v1177 = constructor_umin(ctx, v2.0, v1102.0, v1102.1);
10993
                                                        // Rule at src/opts/selects.isle line 62.
10994
0
                                                        returns.extend(Some(v1177));
10995
0
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
10996
0
                                                    }
10997
0
                                                }
10998
                                            }
10999
                                            &IntCC::UnsignedLessThan => {
11000
0
                                                let v1102 = C::unpack_value_array_2(ctx, v1100);
11001
0
                                                if v86.1 == v1102.0 {
11002
0
                                                    if v86.2 == v1102.1 {
11003
0
                                                        let v1177 = constructor_umin(ctx, v2.0, v1102.0, v1102.1);
11004
                                                        // Rule at src/opts/selects.isle line 51.
11005
0
                                                        returns.extend(Some(v1177));
11006
0
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
11007
0
                                                    }
11008
0
                                                }
11009
0
                                                if v86.1 == v1102.1 {
11010
0
                                                    if v86.2 == v1102.0 {
11011
0
                                                        let v1175 = constructor_umax(ctx, v2.0, v1102.0, v1102.1);
11012
                                                        // Rule at src/opts/selects.isle line 57.
11013
0
                                                        returns.extend(Some(v1175));
11014
0
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
11015
0
                                                    }
11016
0
                                                }
11017
                                            }
11018
                                            &IntCC::UnsignedLessThanOrEqual => {
11019
0
                                                let v1102 = C::unpack_value_array_2(ctx, v1100);
11020
0
                                                if v86.1 == v1102.0 {
11021
0
                                                    if v86.2 == v1102.1 {
11022
0
                                                        let v1177 = constructor_umin(ctx, v2.0, v1102.0, v1102.1);
11023
                                                        // Rule at src/opts/selects.isle line 52.
11024
0
                                                        returns.extend(Some(v1177));
11025
0
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
11026
0
                                                    }
11027
0
                                                }
11028
0
                                                if v86.1 == v1102.1 {
11029
0
                                                    if v86.2 == v1102.0 {
11030
0
                                                        let v1175 = constructor_umax(ctx, v2.0, v1102.0, v1102.1);
11031
                                                        // Rule at src/opts/selects.isle line 58.
11032
0
                                                        returns.extend(Some(v1175));
11033
0
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
11034
0
                                                    }
11035
0
                                                }
11036
                                            }
11037
0
                                            _ => {}
11038
                                        }
11039
0
                                    }
11040
0
                                }
11041
                            }
11042
0
                        }
11043
0
                        let v86 = C::unpack_value_array_3(ctx, v85);
11044
0
                        if v86.1 == v86.2 {
11045
0
                            let v651 = C::subsume(ctx, v86.1);
11046
                            // Rule at src/opts/selects.isle line 4.
11047
0
                            returns.extend(Some(v651));
11048
0
                            if returns.len() >= MAX_ISLE_RETURNS { return; }
11049
0
                        }
11050
                    }
11051
                    &Opcode::Fma => {
11052
0
                        let v86 = C::unpack_value_array_3(ctx, v85);
11053
0
                        let mut v90 = C::inst_data_value_etor_returns::default();
11054
0
                        C::inst_data_value_etor(ctx, v86.0, &mut v90);
11055
0
                        let mut v90 = v90.into_context_iter();
11056
0
                        while let Some(v91) = v90.next(ctx) {
11057
                            if let &InstructionData::Unary {
11058
0
                                opcode: ref v94,
11059
0
                                arg: v95,
11060
0
                            } = &v91.1 {
11061
0
                                if let &Opcode::Fneg = v94 {
11062
0
                                    if v2.0 == v91.0 {
11063
0
                                        let mut v96 = C::inst_data_value_etor_returns::default();
11064
0
                                        C::inst_data_value_etor(ctx, v86.1, &mut v96);
11065
0
                                        let mut v96 = v96.into_context_iter();
11066
0
                                        while let Some(v97) = v96.next(ctx) {
11067
                                            if let &InstructionData::Unary {
11068
0
                                                opcode: ref v100,
11069
0
                                                arg: v101,
11070
0
                                            } = &v97.1 {
11071
0
                                                if let &Opcode::Fneg = v100 {
11072
0
                                                    if v2.0 == v97.0 {
11073
0
                                                        let v102 = constructor_fma(ctx, v2.0, v95, v101, v86.2);
11074
                                                        // Rule at src/opts/arithmetic.isle line 186.
11075
0
                                                        returns.extend(Some(v102));
11076
0
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
11077
0
                                                    }
11078
0
                                                }
11079
0
                                            }
11080
                                        }
11081
0
                                    }
11082
0
                                }
11083
0
                            }
11084
                        }
11085
                    }
11086
0
                    _ => {}
11087
                }
11088
            }
11089
            &InstructionData::Unary {
11090
900k
                opcode: ref v32,
11091
900k
                arg: v33,
11092
            } => {
11093
900k
                match v32 {
11094
                    &Opcode::Splat => {
11095
0
                        let mut v34 = C::inst_data_value_etor_returns::default();
11096
0
                        C::inst_data_value_etor(ctx, v33, &mut v34);
11097
0
                        let mut v34 = v34.into_context_iter();
11098
0
                        while let Some(v35) = v34.next(ctx) {
11099
0
                            match &v35.1 {
11100
                                &InstructionData::UnaryIeee32 {
11101
0
                                    opcode: ref v707,
11102
0
                                    imm: v708,
11103
                                } => {
11104
0
                                    if let &Opcode::F32const = v707 {
11105
0
                                        let v709 = C::u32_from_ieee32(ctx, v708);
11106
0
                                        let v710 = C::u32_into_u64(ctx, v709);
11107
0
                                        let v711 = constructor_splat32(ctx, v710);
11108
0
                                        let v712 = constructor_vconst(ctx, v2.0, v711);
11109
                                        // Rule at src/opts/cprop.isle line 211.
11110
0
                                        returns.extend(Some(v712));
11111
0
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
11112
0
                                    }
11113
                                }
11114
                                &InstructionData::UnaryIeee64 {
11115
0
                                    opcode: ref v713,
11116
0
                                    imm: v714,
11117
                                } => {
11118
0
                                    if let &Opcode::F64const = v713 {
11119
0
                                        let v715 = C::u64_from_ieee64(ctx, v714);
11120
0
                                        let v716 = C::splat64(ctx, v715);
11121
0
                                        let v717 = constructor_vconst(ctx, v2.0, v716);
11122
                                        // Rule at src/opts/cprop.isle line 213.
11123
0
                                        returns.extend(Some(v717));
11124
0
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
11125
0
                                    }
11126
                                }
11127
                                &InstructionData::UnaryImm {
11128
0
                                    opcode: ref v567,
11129
0
                                    imm: v568,
11130
                                } => {
11131
0
                                    if let &Opcode::Iconst = v567 {
11132
0
                                        match v35.0 {
11133
                                            I8 => {
11134
0
                                                let v692 = C::u64_uextend_imm64(ctx, I8, v568);
11135
0
                                                let v693 = constructor_splat8(ctx, v692);
11136
0
                                                let v694 = constructor_vconst(ctx, v2.0, v693);
11137
                                                // Rule at src/opts/cprop.isle line 203.
11138
0
                                                returns.extend(Some(v694));
11139
0
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
11140
                                            }
11141
                                            I16 => {
11142
0
                                                let v696 = C::u64_uextend_imm64(ctx, I16, v568);
11143
0
                                                let v697 = constructor_splat16(ctx, v696);
11144
0
                                                let v698 = constructor_vconst(ctx, v2.0, v697);
11145
                                                // Rule at src/opts/cprop.isle line 205.
11146
0
                                                returns.extend(Some(v698));
11147
0
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
11148
                                            }
11149
                                            I32 => {
11150
0
                                                let v700 = C::u64_uextend_imm64(ctx, I32, v568);
11151
0
                                                let v701 = constructor_splat32(ctx, v700);
11152
0
                                                let v702 = constructor_vconst(ctx, v2.0, v701);
11153
                                                // Rule at src/opts/cprop.isle line 207.
11154
0
                                                returns.extend(Some(v702));
11155
0
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
11156
                                            }
11157
                                            I64 => {
11158
0
                                                let v704 = C::u64_uextend_imm64(ctx, I64, v568);
11159
0
                                                let v705 = C::splat64(ctx, v704);
11160
0
                                                let v706 = constructor_vconst(ctx, v2.0, v705);
11161
                                                // Rule at src/opts/cprop.isle line 209.
11162
0
                                                returns.extend(Some(v706));
11163
0
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
11164
                                            }
11165
0
                                            _ => {}
11166
                                        }
11167
0
                                    }
11168
                                }
11169
0
                                _ => {}
11170
                            }
11171
                        }
11172
                    }
11173
                    &Opcode::Ineg => {
11174
10.3k
                        let mut v34 = C::inst_data_value_etor_returns::default();
11175
10.3k
                        C::inst_data_value_etor(ctx, v33, &mut v34);
11176
10.3k
                        let mut v34 = v34.into_context_iter();
11177
21.4k
                        while let Some(
v3511.0k
) = v34.next(ctx) {
11178
11.0k
                            match &v35.1 {
11179
                                &InstructionData::Binary {
11180
5.18k
                                    opcode: ref v38,
11181
5.18k
                                    args: ref v39,
11182
                                } => {
11183
5.18k
                                    match v38 {
11184
                                        &Opcode::Isub => {
11185
3.83k
                                            if v2.0 == v35.0 {
11186
3.83k
                                                let v40 = C::unpack_value_array_2(ctx, v39);
11187
3.83k
                                                let v43 = constructor_isub(ctx, v2.0, v40.1, v40.0);
11188
                                                // Rule at src/opts/arithmetic.isle line 27.
11189
3.83k
                                                returns.extend(Some(v43));
11190
3.83k
                                                if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
11191
0
                                            }
11192
                                        }
11193
                                        &Opcode::Ushr => {
11194
24
                                            if v2.0 == v35.0 {
11195
24
                                                let v40 = C::unpack_value_array_2(ctx, v39);
11196
24
                                                let mut v1238 = C::inst_data_value_etor_returns::default();
11197
24
                                                C::inst_data_value_etor(ctx, v40.1, &mut v1238);
11198
24
                                                let mut v1238 = v1238.into_context_iter();
11199
48
                                                while let Some(
v123924
) = v1238.next(ctx) {
11200
                                                    if let &InstructionData::UnaryImm {
11201
24
                                                        opcode: ref v1242,
11202
24
                                                        imm: v1243,
11203
24
                                                    } = &v1239.1 {
11204
24
                                                        if let &Opcode::Iconst = v1242 {
11205
24
                                                            let v1244 = C::u64_from_imm64(ctx, v1243);
11206
24
                                                            let v250 = constructor_ty_shift_mask(ctx, v2.0);
11207
24
                                                            let v1245 = C::u64_eq(ctx, v1244, v250);
11208
24
                                                            if v1245 == true {
11209
0
                                                                if v2.0 == v1239.0 {
11210
0
                                                                    let v1246 = constructor_sshr(ctx, v2.0, v40.0, v40.1);
11211
                                                                    // Rule at src/opts/shifts.isle line 98.
11212
0
                                                                    returns.extend(Some(v1246));
11213
0
                                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
11214
0
                                                                }
11215
24
                                                            }
11216
0
                                                        }
11217
0
                                                    }
11218
                                                }
11219
0
                                            }
11220
                                        }
11221
1.33k
                                        _ => {}
11222
                                    }
11223
                                }
11224
                                &InstructionData::Unary {
11225
48
                                    opcode: ref v45,
11226
48
                                    arg: v46,
11227
                                } => {
11228
48
                                    match v45 {
11229
                                        &Opcode::Splat => {
11230
0
                                            if v2.0 == v35.0 {
11231
0
                                                let v1262 = C::lane_type(ctx, v2.0);
11232
0
                                                let v1400 = constructor_ineg(ctx, v1262, v46);
11233
0
                                                let v1401 = constructor_splat(ctx, v2.0, v1400);
11234
                                                // Rule at src/opts/vector.isle line 45.
11235
0
                                                returns.extend(Some(v1401));
11236
0
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
11237
0
                                            }
11238
                                        }
11239
                                        &Opcode::Ineg => {
11240
0
                                            if v2.0 == v35.0 {
11241
0
                                                let v47 = C::subsume(ctx, v46);
11242
                                                // Rule at src/opts/arithmetic.isle line 34.
11243
0
                                                returns.extend(Some(v47));
11244
0
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
11245
0
                                            }
11246
                                        }
11247
48
                                        _ => {}
11248
                                    }
11249
                                }
11250
5.82k
                                _ => {}
11251
                            }
11252
                        }
11253
                    }
11254
                    &Opcode::Iabs => {
11255
0
                        let mut v34 = C::inst_data_value_etor_returns::default();
11256
0
                        C::inst_data_value_etor(ctx, v33, &mut v34);
11257
0
                        let mut v34 = v34.into_context_iter();
11258
0
                        while let Some(v35) = v34.next(ctx) {
11259
                            if let &InstructionData::Unary {
11260
0
                                opcode: ref v45,
11261
0
                                arg: v46,
11262
0
                            } = &v35.1 {
11263
0
                                match v45 {
11264
                                    &Opcode::Splat => {
11265
0
                                        if v2.0 == v35.0 {
11266
0
                                            let v1262 = C::lane_type(ctx, v2.0);
11267
0
                                            let v1402 = constructor_iabs(ctx, v1262, v46);
11268
0
                                            let v1403 = constructor_splat(ctx, v2.0, v1402);
11269
                                            // Rule at src/opts/vector.isle line 48.
11270
0
                                            returns.extend(Some(v1403));
11271
0
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
11272
0
                                        }
11273
                                    }
11274
                                    &Opcode::Ineg => {
11275
0
                                        if v2.0 == v35.0 {
11276
0
                                            let v50 = constructor_iabs(ctx, v2.0, v46);
11277
                                            // Rule at src/opts/arithmetic.isle line 41.
11278
0
                                            returns.extend(Some(v50));
11279
0
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
11280
0
                                        }
11281
                                    }
11282
                                    &Opcode::Iabs => {
11283
0
                                        if v2.0 == v35.0 {
11284
0
                                            let v51 = C::subsume(ctx, v33);
11285
                                            // Rule at src/opts/arithmetic.isle line 45.
11286
0
                                            returns.extend(Some(v51));
11287
0
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
11288
0
                                        }
11289
                                    }
11290
0
                                    _ => {}
11291
                                }
11292
0
                            }
11293
                        }
11294
                    }
11295
                    &Opcode::Bnot => {
11296
1.51k
                        let mut v34 = C::inst_data_value_etor_returns::default();
11297
1.51k
                        C::inst_data_value_etor(ctx, v33, &mut v34);
11298
1.51k
                        let mut v34 = v34.into_context_iter();
11299
2.60k
                        while let Some(
v351.09k
) = v34.next(ctx) {
11300
1.09k
                            match &v35.1 {
11301
                                &InstructionData::Binary {
11302
523
                                    opcode: ref v38,
11303
523
                                    args: ref v39,
11304
                                } => {
11305
523
                                    match v38 {
11306
                                        &Opcode::Iadd => {
11307
307
                                            if v2.0 == v35.0 {
11308
307
                                                let v40 = C::unpack_value_array_2(ctx, v39);
11309
307
                                                let mut v66 = C::inst_data_value_tupled_etor_returns::default();
11310
307
                                                C::inst_data_value_tupled_etor(ctx, v40.1, &mut v66);
11311
307
                                                let mut v66 = v66.into_context_iter();
11312
543
                                                while let Some(
v67236
) = v66.next(ctx) {
11313
236
                                                    let v68 = C::iconst_sextend_etor(ctx, v67);
11314
236
                                                    if let Some(
v69110
) = v68 {
11315
110
                                                        if v69.1 == -1_i64 {
11316
0
                                                            if v2.0 == v69.0 {
11317
0
                                                                let v72 = constructor_ineg(ctx, v2.0, v40.0);
11318
                                                                // Rule at src/opts/arithmetic.isle line 74.
11319
0
                                                                returns.extend(Some(v72));
11320
0
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
11321
0
                                                            }
11322
110
                                                        }
11323
126
                                                    }
11324
                                                }
11325
0
                                            }
11326
                                        }
11327
                                        &Opcode::Isub => {
11328
0
                                            if v2.0 == v35.0 {
11329
0
                                                let v40 = C::unpack_value_array_2(ctx, v39);
11330
0
                                                let mut v66 = C::inst_data_value_tupled_etor_returns::default();
11331
0
                                                C::inst_data_value_tupled_etor(ctx, v40.1, &mut v66);
11332
0
                                                let mut v66 = v66.into_context_iter();
11333
0
                                                while let Some(v67) = v66.next(ctx) {
11334
0
                                                    let v68 = C::iconst_sextend_etor(ctx, v67);
11335
0
                                                    if let Some(v69) = v68 {
11336
0
                                                        if v69.1 == 1_i64 {
11337
0
                                                            if v2.0 == v69.0 {
11338
0
                                                                let v72 = constructor_ineg(ctx, v2.0, v40.0);
11339
                                                                // Rule at src/opts/arithmetic.isle line 72.
11340
0
                                                                returns.extend(Some(v72));
11341
0
                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
11342
0
                                                            }
11343
0
                                                        }
11344
0
                                                    }
11345
                                                }
11346
0
                                            }
11347
                                        }
11348
                                        &Opcode::Band => {
11349
4
                                            let v40 = C::unpack_value_array_2(ctx, v39);
11350
4
                                            let v235 = constructor_bnot(ctx, v2.0, v40.0);
11351
4
                                            let v236 = constructor_bnot(ctx, v2.0, v40.1);
11352
4
                                            let v238 = constructor_bor(ctx, v2.0, v235, v236);
11353
                                            // Rule at src/opts/bitops.isle line 48.
11354
4
                                            returns.extend(Some(v238));
11355
4
                                            if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
11356
                                        }
11357
                                        &Opcode::Bor => {
11358
0
                                            if v2.0 == v35.0 {
11359
0
                                                let v40 = C::unpack_value_array_2(ctx, v39);
11360
0
                                                let v235 = constructor_bnot(ctx, v2.0, v40.0);
11361
0
                                                let v236 = constructor_bnot(ctx, v2.0, v40.1);
11362
0
                                                let v237 = constructor_band(ctx, v2.0, v235, v236);
11363
                                                // Rule at src/opts/bitops.isle line 45.
11364
0
                                                returns.extend(Some(v237));
11365
0
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
11366
0
                                            }
11367
                                        }
11368
212
                                        _ => {}
11369
                                    }
11370
                                }
11371
                                &InstructionData::Unary {
11372
18
                                    opcode: ref v45,
11373
18
                                    arg: v46,
11374
                                } => {
11375
18
                                    match v45 {
11376
                                        &Opcode::Splat => {
11377
0
                                            let v1380 = C::ty_vector_not_float(ctx, v2.0);
11378
0
                                            if let Some(v1381) = v1380 {
11379
0
                                                if v2.0 == v35.0 {
11380
0
                                                    let v1262 = C::lane_type(ctx, v2.0);
11381
0
                                                    let v1388 = constructor_bnot(ctx, v1262, v46);
11382
0
                                                    let v1389 = constructor_splat(ctx, v2.0, v1388);
11383
                                                    // Rule at src/opts/vector.isle line 26.
11384
0
                                                    returns.extend(Some(v1389));
11385
0
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
11386
0
                                                }
11387
0
                                            }
11388
                                        }
11389
                                        &Opcode::Bnot => {
11390
0
                                            if v2.0 == v35.0 {
11391
0
                                                let v47 = C::subsume(ctx, v46);
11392
                                                // Rule at src/opts/bitops.isle line 41.
11393
0
                                                returns.extend(Some(v47));
11394
0
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
11395
0
                                            }
11396
                                        }
11397
18
                                        _ => {}
11398
                                    }
11399
                                }
11400
                                &InstructionData::UnaryImm {
11401
0
                                    opcode: ref v567,
11402
0
                                    imm: v568,
11403
                                } => {
11404
0
                                    if let &Opcode::Iconst = v567 {
11405
0
                                        let v541 = C::fits_in_64(ctx, v2.0);
11406
0
                                        if let Some(v542) = v541 {
11407
0
                                            if v35.0 == v542 {
11408
0
                                                let v569 = C::u64_from_imm64(ctx, v568);
11409
0
                                                let v570 = C::u64_not(ctx, v569);
11410
0
                                                let v571 = C::imm64_masked(ctx, v542, v570);
11411
0
                                                let v572 = constructor_iconst(ctx, v542, v571);
11412
0
                                                let v573 = C::subsume(ctx, v572);
11413
                                                // Rule at src/opts/cprop.isle line 50.
11414
0
                                                returns.extend(Some(v573));
11415
0
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
11416
0
                                            }
11417
0
                                        }
11418
0
                                    }
11419
                                }
11420
555
                                _ => {}
11421
                            }
11422
                        }
11423
1.51k
                        let v1142 = C::remat(ctx, arg0);
11424
                        // Rule at src/opts/remat.isle line 23.
11425
1.51k
                        returns.extend(Some(v1142));
11426
1.51k
                        if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
11427
                    }
11428
                    &Opcode::Bitrev => {
11429
0
                        let mut v34 = C::inst_data_value_etor_returns::default();
11430
0
                        C::inst_data_value_etor(ctx, v33, &mut v34);
11431
0
                        let mut v34 = v34.into_context_iter();
11432
0
                        while let Some(v35) = v34.next(ctx) {
11433
                            if let &InstructionData::Unary {
11434
0
                                opcode: ref v45,
11435
0
                                arg: v46,
11436
0
                            } = &v35.1 {
11437
0
                                if let &Opcode::Bitrev = v45 {
11438
0
                                    if v2.0 == v35.0 {
11439
0
                                        let v47 = C::subsume(ctx, v46);
11440
                                        // Rule at src/opts/bitops.isle line 139.
11441
0
                                        returns.extend(Some(v47));
11442
0
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
11443
0
                                    }
11444
0
                                }
11445
0
                            }
11446
                        }
11447
                    }
11448
                    &Opcode::Bswap => {
11449
0
                        let mut v34 = C::inst_data_value_etor_returns::default();
11450
0
                        C::inst_data_value_etor(ctx, v33, &mut v34);
11451
0
                        let mut v34 = v34.into_context_iter();
11452
0
                        while let Some(v35) = v34.next(ctx) {
11453
0
                            match &v35.1 {
11454
                                &InstructionData::Unary {
11455
0
                                    opcode: ref v45,
11456
0
                                    arg: v46,
11457
                                } => {
11458
0
                                    if let &Opcode::Bswap = v45 {
11459
0
                                        if v2.0 == v35.0 {
11460
0
                                            let v47 = C::subsume(ctx, v46);
11461
                                            // Rule at src/opts/bitops.isle line 136.
11462
0
                                            returns.extend(Some(v47));
11463
0
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
11464
0
                                        }
11465
0
                                    }
11466
                                }
11467
                                &InstructionData::UnaryImm {
11468
0
                                    opcode: ref v567,
11469
0
                                    imm: v568,
11470
                                } => {
11471
0
                                    if let &Opcode::Iconst = v567 {
11472
0
                                        match v2.0 {
11473
                                            I16 => {
11474
0
                                                let v569 = C::u64_from_imm64(ctx, v568);
11475
0
                                                let v751 = C::u64_bswap16(ctx, v569);
11476
0
                                                let v752 = C::imm64(ctx, v751);
11477
0
                                                let v753 = constructor_iconst(ctx, I16, v752);
11478
0
                                                let v754 = C::subsume(ctx, v753);
11479
                                                // Rule at src/opts/cprop.isle line 283.
11480
0
                                                returns.extend(Some(v754));
11481
0
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
11482
                                            }
11483
                                            I32 => {
11484
0
                                                let v569 = C::u64_from_imm64(ctx, v568);
11485
0
                                                let v755 = C::u64_bswap32(ctx, v569);
11486
0
                                                let v756 = C::imm64(ctx, v755);
11487
0
                                                let v757 = constructor_iconst(ctx, I32, v756);
11488
0
                                                let v758 = C::subsume(ctx, v757);
11489
                                                // Rule at src/opts/cprop.isle line 285.
11490
0
                                                returns.extend(Some(v758));
11491
0
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
11492
                                            }
11493
                                            I64 => {
11494
0
                                                let v569 = C::u64_from_imm64(ctx, v568);
11495
0
                                                let v759 = C::u64_bswap64(ctx, v569);
11496
0
                                                let v760 = C::imm64(ctx, v759);
11497
0
                                                let v761 = constructor_iconst(ctx, I64, v760);
11498
0
                                                let v762 = C::subsume(ctx, v761);
11499
                                                // Rule at src/opts/cprop.isle line 287.
11500
0
                                                returns.extend(Some(v762));
11501
0
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
11502
                                            }
11503
0
                                            _ => {}
11504
                                        }
11505
0
                                    }
11506
                                }
11507
0
                                _ => {}
11508
                            }
11509
                        }
11510
                    }
11511
                    &Opcode::Popcnt => {
11512
89
                        let mut v34 = C::inst_data_value_etor_returns::default();
11513
89
                        C::inst_data_value_etor(ctx, v33, &mut v34);
11514
89
                        let mut v34 = v34.into_context_iter();
11515
186
                        while let Some(
v3597
) = v34.next(ctx) {
11516
                            if let &InstructionData::Unary {
11517
8
                                opcode: ref v45,
11518
8
                                arg: v46,
11519
97
                            } = &v35.1 {
11520
8
                                if let &Opcode::Splat = v45 {
11521
0
                                    if v2.0 == v35.0 {
11522
0
                                        let v1262 = C::lane_type(ctx, v2.0);
11523
0
                                        let v1404 = constructor_popcnt(ctx, v1262, v46);
11524
0
                                        let v1405 = constructor_splat(ctx, v2.0, v1404);
11525
                                        // Rule at src/opts/vector.isle line 51.
11526
0
                                        returns.extend(Some(v1405));
11527
0
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
11528
0
                                    }
11529
8
                                }
11530
89
                            }
11531
                        }
11532
                    }
11533
                    &Opcode::Sqrt => {
11534
0
                        match v2.0 {
11535
                            F32 => {
11536
0
                                let mut v34 = C::inst_data_value_etor_returns::default();
11537
0
                                C::inst_data_value_etor(ctx, v33, &mut v34);
11538
0
                                let mut v34 = v34.into_context_iter();
11539
0
                                while let Some(v35) = v34.next(ctx) {
11540
0
                                    if v35.0 == F32 {
11541
                                        if let &InstructionData::UnaryIeee32 {
11542
0
                                            opcode: ref v707,
11543
0
                                            imm: v708,
11544
0
                                        } = &v35.1 {
11545
0
                                            if let &Opcode::F32const = v707 {
11546
0
                                                let v803 = C::f32_sqrt(ctx, v708);
11547
0
                                                if let Some(v804) = v803 {
11548
0
                                                    let v805 = constructor_f32const(ctx, F32, v804);
11549
0
                                                    let v806 = C::subsume(ctx, v805);
11550
                                                    // Rule at src/opts/cprop.isle line 334.
11551
0
                                                    returns.extend(Some(v806));
11552
0
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
11553
0
                                                }
11554
0
                                            }
11555
0
                                        }
11556
0
                                    }
11557
                                }
11558
                            }
11559
                            F64 => {
11560
0
                                let mut v34 = C::inst_data_value_etor_returns::default();
11561
0
                                C::inst_data_value_etor(ctx, v33, &mut v34);
11562
0
                                let mut v34 = v34.into_context_iter();
11563
0
                                while let Some(v35) = v34.next(ctx) {
11564
0
                                    if v35.0 == F64 {
11565
                                        if let &InstructionData::UnaryIeee64 {
11566
0
                                            opcode: ref v713,
11567
0
                                            imm: v714,
11568
0
                                        } = &v35.1 {
11569
0
                                            if let &Opcode::F64const = v713 {
11570
0
                                                let v807 = C::f64_sqrt(ctx, v714);
11571
0
                                                if let Some(v808) = v807 {
11572
0
                                                    let v809 = constructor_f64const(ctx, F64, v808);
11573
0
                                                    let v810 = C::subsume(ctx, v809);
11574
                                                    // Rule at src/opts/cprop.isle line 337.
11575
0
                                                    returns.extend(Some(v810));
11576
0
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
11577
0
                                                }
11578
0
                                            }
11579
0
                                        }
11580
0
                                    }
11581
                                }
11582
                            }
11583
0
                            _ => {}
11584
                        }
11585
                    }
11586
                    &Opcode::Fneg => {
11587
0
                        let mut v34 = C::inst_data_value_etor_returns::default();
11588
0
                        C::inst_data_value_etor(ctx, v33, &mut v34);
11589
0
                        let mut v34 = v34.into_context_iter();
11590
0
                        while let Some(v35) = v34.next(ctx) {
11591
0
                            match &v35.1 {
11592
                                &InstructionData::Unary {
11593
0
                                    opcode: ref v45,
11594
0
                                    arg: v46,
11595
                                } => {
11596
0
                                    if let &Opcode::Fneg = v45 {
11597
0
                                        if v2.0 == v35.0 {
11598
0
                                            let v47 = C::subsume(ctx, v46);
11599
                                            // Rule at src/opts/arithmetic.isle line 182.
11600
0
                                            returns.extend(Some(v47));
11601
0
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
11602
0
                                        }
11603
0
                                    }
11604
                                }
11605
                                &InstructionData::UnaryConst {
11606
0
                                    opcode: ref v902,
11607
0
                                    constant_handle: v903,
11608
                                } => {
11609
0
                                    if let &Opcode::F128const = v902 {
11610
0
                                        if v2.0 == F128 {
11611
0
                                            if v35.0 == F128 {
11612
0
                                                let v904 = C::ieee128_constant_extractor(ctx, v903);
11613
0
                                                if let Some(v905) = v904 {
11614
0
                                                    let v906 = C::f128_neg(ctx, v905);
11615
0
                                                    let v907 = C::ieee128_constant(ctx, v906);
11616
0
                                                    let v908 = constructor_f128const(ctx, F128, v907);
11617
0
                                                    let v909 = C::subsume(ctx, v908);
11618
                                                    // Rule at src/opts/cprop.isle line 401.
11619
0
                                                    returns.extend(Some(v909));
11620
0
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
11621
0
                                                }
11622
0
                                            }
11623
0
                                        }
11624
0
                                    }
11625
                                }
11626
                                &InstructionData::UnaryIeee16 {
11627
0
                                    opcode: ref v891,
11628
0
                                    imm: v892,
11629
                                } => {
11630
0
                                    if let &Opcode::F16const = v891 {
11631
0
                                        if v2.0 == F16 {
11632
0
                                            if v35.0 == F16 {
11633
0
                                                let v893 = C::f16_neg(ctx, v892);
11634
0
                                                let v894 = constructor_f16const(ctx, F16, v893);
11635
0
                                                let v895 = C::subsume(ctx, v894);
11636
                                                // Rule at src/opts/cprop.isle line 395.
11637
0
                                                returns.extend(Some(v895));
11638
0
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
11639
0
                                            }
11640
0
                                        }
11641
0
                                    }
11642
                                }
11643
                                &InstructionData::UnaryIeee32 {
11644
0
                                    opcode: ref v707,
11645
0
                                    imm: v708,
11646
                                } => {
11647
0
                                    if let &Opcode::F32const = v707 {
11648
0
                                        if v2.0 == F32 {
11649
0
                                            if v35.0 == F32 {
11650
0
                                                let v896 = C::f32_neg(ctx, v708);
11651
0
                                                let v897 = constructor_f32const(ctx, F32, v896);
11652
0
                                                let v898 = C::subsume(ctx, v897);
11653
                                                // Rule at src/opts/cprop.isle line 397.
11654
0
                                                returns.extend(Some(v898));
11655
0
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
11656
0
                                            }
11657
0
                                        }
11658
0
                                    }
11659
                                }
11660
                                &InstructionData::UnaryIeee64 {
11661
0
                                    opcode: ref v713,
11662
0
                                    imm: v714,
11663
                                } => {
11664
0
                                    if let &Opcode::F64const = v713 {
11665
0
                                        if v2.0 == F64 {
11666
0
                                            if v35.0 == F64 {
11667
0
                                                let v899 = C::f64_neg(ctx, v714);
11668
0
                                                let v900 = constructor_f64const(ctx, F64, v899);
11669
0
                                                let v901 = C::subsume(ctx, v900);
11670
                                                // Rule at src/opts/cprop.isle line 399.
11671
0
                                                returns.extend(Some(v901));
11672
0
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
11673
0
                                            }
11674
0
                                        }
11675
0
                                    }
11676
                                }
11677
0
                                _ => {}
11678
                            }
11679
                        }
11680
                    }
11681
                    &Opcode::Fabs => {
11682
0
                        match v2.0 {
11683
                            F16 => {
11684
0
                                let mut v34 = C::inst_data_value_etor_returns::default();
11685
0
                                C::inst_data_value_etor(ctx, v33, &mut v34);
11686
0
                                let mut v34 = v34.into_context_iter();
11687
0
                                while let Some(v35) = v34.next(ctx) {
11688
0
                                    if v35.0 == F16 {
11689
                                        if let &InstructionData::UnaryIeee16 {
11690
0
                                            opcode: ref v891,
11691
0
                                            imm: v892,
11692
0
                                        } = &v35.1 {
11693
0
                                            if let &Opcode::F16const = v891 {
11694
0
                                                let v910 = C::f16_abs(ctx, v892);
11695
0
                                                let v911 = constructor_f16const(ctx, F16, v910);
11696
0
                                                let v912 = C::subsume(ctx, v911);
11697
                                                // Rule at src/opts/cprop.isle line 404.
11698
0
                                                returns.extend(Some(v912));
11699
0
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
11700
0
                                            }
11701
0
                                        }
11702
0
                                    }
11703
                                }
11704
                            }
11705
                            F32 => {
11706
0
                                let mut v34 = C::inst_data_value_etor_returns::default();
11707
0
                                C::inst_data_value_etor(ctx, v33, &mut v34);
11708
0
                                let mut v34 = v34.into_context_iter();
11709
0
                                while let Some(v35) = v34.next(ctx) {
11710
0
                                    if v35.0 == F32 {
11711
                                        if let &InstructionData::UnaryIeee32 {
11712
0
                                            opcode: ref v707,
11713
0
                                            imm: v708,
11714
0
                                        } = &v35.1 {
11715
0
                                            if let &Opcode::F32const = v707 {
11716
0
                                                let v913 = C::f32_abs(ctx, v708);
11717
0
                                                let v914 = constructor_f32const(ctx, F32, v913);
11718
0
                                                let v915 = C::subsume(ctx, v914);
11719
                                                // Rule at src/opts/cprop.isle line 406.
11720
0
                                                returns.extend(Some(v915));
11721
0
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
11722
0
                                            }
11723
0
                                        }
11724
0
                                    }
11725
                                }
11726
                            }
11727
                            F64 => {
11728
0
                                let mut v34 = C::inst_data_value_etor_returns::default();
11729
0
                                C::inst_data_value_etor(ctx, v33, &mut v34);
11730
0
                                let mut v34 = v34.into_context_iter();
11731
0
                                while let Some(v35) = v34.next(ctx) {
11732
0
                                    if v35.0 == F64 {
11733
                                        if let &InstructionData::UnaryIeee64 {
11734
0
                                            opcode: ref v713,
11735
0
                                            imm: v714,
11736
0
                                        } = &v35.1 {
11737
0
                                            if let &Opcode::F64const = v713 {
11738
0
                                                let v916 = C::f64_abs(ctx, v714);
11739
0
                                                let v917 = constructor_f64const(ctx, F64, v916);
11740
0
                                                let v918 = C::subsume(ctx, v917);
11741
                                                // Rule at src/opts/cprop.isle line 408.
11742
0
                                                returns.extend(Some(v918));
11743
0
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
11744
0
                                            }
11745
0
                                        }
11746
0
                                    }
11747
                                }
11748
                            }
11749
                            F128 => {
11750
0
                                let mut v34 = C::inst_data_value_etor_returns::default();
11751
0
                                C::inst_data_value_etor(ctx, v33, &mut v34);
11752
0
                                let mut v34 = v34.into_context_iter();
11753
0
                                while let Some(v35) = v34.next(ctx) {
11754
0
                                    if v35.0 == F128 {
11755
                                        if let &InstructionData::UnaryConst {
11756
0
                                            opcode: ref v902,
11757
0
                                            constant_handle: v903,
11758
0
                                        } = &v35.1 {
11759
0
                                            if let &Opcode::F128const = v902 {
11760
0
                                                let v904 = C::ieee128_constant_extractor(ctx, v903);
11761
0
                                                if let Some(v905) = v904 {
11762
0
                                                    let v919 = C::f128_abs(ctx, v905);
11763
0
                                                    let v920 = C::ieee128_constant(ctx, v919);
11764
0
                                                    let v921 = constructor_f128const(ctx, F128, v920);
11765
0
                                                    let v922 = C::subsume(ctx, v921);
11766
                                                    // Rule at src/opts/cprop.isle line 410.
11767
0
                                                    returns.extend(Some(v922));
11768
0
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
11769
0
                                                }
11770
0
                                            }
11771
0
                                        }
11772
0
                                    }
11773
                                }
11774
                            }
11775
0
                            _ => {}
11776
                        }
11777
                    }
11778
                    &Opcode::Ceil => {
11779
0
                        match v2.0 {
11780
                            F32 => {
11781
0
                                let mut v34 = C::inst_data_value_etor_returns::default();
11782
0
                                C::inst_data_value_etor(ctx, v33, &mut v34);
11783
0
                                let mut v34 = v34.into_context_iter();
11784
0
                                while let Some(v35) = v34.next(ctx) {
11785
0
                                    if v35.0 == F32 {
11786
                                        if let &InstructionData::UnaryIeee32 {
11787
0
                                            opcode: ref v707,
11788
0
                                            imm: v708,
11789
0
                                        } = &v35.1 {
11790
0
                                            if let &Opcode::F32const = v707 {
11791
0
                                                let v811 = C::f32_ceil(ctx, v708);
11792
0
                                                if let Some(v812) = v811 {
11793
0
                                                    let v813 = constructor_f32const(ctx, F32, v812);
11794
0
                                                    let v814 = C::subsume(ctx, v813);
11795
                                                    // Rule at src/opts/cprop.isle line 341.
11796
0
                                                    returns.extend(Some(v814));
11797
0
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
11798
0
                                                }
11799
0
                                            }
11800
0
                                        }
11801
0
                                    }
11802
                                }
11803
                            }
11804
                            F64 => {
11805
0
                                let mut v34 = C::inst_data_value_etor_returns::default();
11806
0
                                C::inst_data_value_etor(ctx, v33, &mut v34);
11807
0
                                let mut v34 = v34.into_context_iter();
11808
0
                                while let Some(v35) = v34.next(ctx) {
11809
0
                                    if v35.0 == F64 {
11810
                                        if let &InstructionData::UnaryIeee64 {
11811
0
                                            opcode: ref v713,
11812
0
                                            imm: v714,
11813
0
                                        } = &v35.1 {
11814
0
                                            if let &Opcode::F64const = v713 {
11815
0
                                                let v815 = C::f64_ceil(ctx, v714);
11816
0
                                                if let Some(v816) = v815 {
11817
0
                                                    let v817 = constructor_f64const(ctx, F64, v816);
11818
0
                                                    let v818 = C::subsume(ctx, v817);
11819
                                                    // Rule at src/opts/cprop.isle line 344.
11820
0
                                                    returns.extend(Some(v818));
11821
0
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
11822
0
                                                }
11823
0
                                            }
11824
0
                                        }
11825
0
                                    }
11826
                                }
11827
                            }
11828
0
                            _ => {}
11829
                        }
11830
                    }
11831
                    &Opcode::Floor => {
11832
0
                        match v2.0 {
11833
                            F32 => {
11834
0
                                let mut v34 = C::inst_data_value_etor_returns::default();
11835
0
                                C::inst_data_value_etor(ctx, v33, &mut v34);
11836
0
                                let mut v34 = v34.into_context_iter();
11837
0
                                while let Some(v35) = v34.next(ctx) {
11838
0
                                    if v35.0 == F32 {
11839
                                        if let &InstructionData::UnaryIeee32 {
11840
0
                                            opcode: ref v707,
11841
0
                                            imm: v708,
11842
0
                                        } = &v35.1 {
11843
0
                                            if let &Opcode::F32const = v707 {
11844
0
                                                let v819 = C::f32_floor(ctx, v708);
11845
0
                                                if let Some(v820) = v819 {
11846
0
                                                    let v821 = constructor_f32const(ctx, F32, v820);
11847
0
                                                    let v822 = C::subsume(ctx, v821);
11848
                                                    // Rule at src/opts/cprop.isle line 348.
11849
0
                                                    returns.extend(Some(v822));
11850
0
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
11851
0
                                                }
11852
0
                                            }
11853
0
                                        }
11854
0
                                    }
11855
                                }
11856
                            }
11857
                            F64 => {
11858
0
                                let mut v34 = C::inst_data_value_etor_returns::default();
11859
0
                                C::inst_data_value_etor(ctx, v33, &mut v34);
11860
0
                                let mut v34 = v34.into_context_iter();
11861
0
                                while let Some(v35) = v34.next(ctx) {
11862
0
                                    if v35.0 == F64 {
11863
                                        if let &InstructionData::UnaryIeee64 {
11864
0
                                            opcode: ref v713,
11865
0
                                            imm: v714,
11866
0
                                        } = &v35.1 {
11867
0
                                            if let &Opcode::F64const = v713 {
11868
0
                                                let v823 = C::f64_floor(ctx, v714);
11869
0
                                                if let Some(v824) = v823 {
11870
0
                                                    let v825 = constructor_f64const(ctx, F64, v824);
11871
0
                                                    let v826 = C::subsume(ctx, v825);
11872
                                                    // Rule at src/opts/cprop.isle line 351.
11873
0
                                                    returns.extend(Some(v826));
11874
0
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
11875
0
                                                }
11876
0
                                            }
11877
0
                                        }
11878
0
                                    }
11879
                                }
11880
                            }
11881
0
                            _ => {}
11882
                        }
11883
                    }
11884
                    &Opcode::Trunc => {
11885
0
                        match v2.0 {
11886
                            F32 => {
11887
0
                                let mut v34 = C::inst_data_value_etor_returns::default();
11888
0
                                C::inst_data_value_etor(ctx, v33, &mut v34);
11889
0
                                let mut v34 = v34.into_context_iter();
11890
0
                                while let Some(v35) = v34.next(ctx) {
11891
0
                                    if v35.0 == F32 {
11892
                                        if let &InstructionData::UnaryIeee32 {
11893
0
                                            opcode: ref v707,
11894
0
                                            imm: v708,
11895
0
                                        } = &v35.1 {
11896
0
                                            if let &Opcode::F32const = v707 {
11897
0
                                                let v827 = C::f32_trunc(ctx, v708);
11898
0
                                                if let Some(v828) = v827 {
11899
0
                                                    let v829 = constructor_f32const(ctx, F32, v828);
11900
0
                                                    let v830 = C::subsume(ctx, v829);
11901
                                                    // Rule at src/opts/cprop.isle line 355.
11902
0
                                                    returns.extend(Some(v830));
11903
0
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
11904
0
                                                }
11905
0
                                            }
11906
0
                                        }
11907
0
                                    }
11908
                                }
11909
                            }
11910
                            F64 => {
11911
0
                                let mut v34 = C::inst_data_value_etor_returns::default();
11912
0
                                C::inst_data_value_etor(ctx, v33, &mut v34);
11913
0
                                let mut v34 = v34.into_context_iter();
11914
0
                                while let Some(v35) = v34.next(ctx) {
11915
0
                                    if v35.0 == F64 {
11916
                                        if let &InstructionData::UnaryIeee64 {
11917
0
                                            opcode: ref v713,
11918
0
                                            imm: v714,
11919
0
                                        } = &v35.1 {
11920
0
                                            if let &Opcode::F64const = v713 {
11921
0
                                                let v831 = C::f64_trunc(ctx, v714);
11922
0
                                                if let Some(v832) = v831 {
11923
0
                                                    let v833 = constructor_f64const(ctx, F64, v832);
11924
0
                                                    let v834 = C::subsume(ctx, v833);
11925
                                                    // Rule at src/opts/cprop.isle line 358.
11926
0
                                                    returns.extend(Some(v834));
11927
0
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
11928
0
                                                }
11929
0
                                            }
11930
0
                                        }
11931
0
                                    }
11932
                                }
11933
                            }
11934
0
                            _ => {}
11935
                        }
11936
                    }
11937
                    &Opcode::Nearest => {
11938
0
                        match v2.0 {
11939
                            F32 => {
11940
0
                                let mut v34 = C::inst_data_value_etor_returns::default();
11941
0
                                C::inst_data_value_etor(ctx, v33, &mut v34);
11942
0
                                let mut v34 = v34.into_context_iter();
11943
0
                                while let Some(v35) = v34.next(ctx) {
11944
0
                                    if v35.0 == F32 {
11945
                                        if let &InstructionData::UnaryIeee32 {
11946
0
                                            opcode: ref v707,
11947
0
                                            imm: v708,
11948
0
                                        } = &v35.1 {
11949
0
                                            if let &Opcode::F32const = v707 {
11950
0
                                                let v835 = C::f32_nearest(ctx, v708);
11951
0
                                                if let Some(v836) = v835 {
11952
0
                                                    let v837 = constructor_f32const(ctx, F32, v836);
11953
0
                                                    let v838 = C::subsume(ctx, v837);
11954
                                                    // Rule at src/opts/cprop.isle line 362.
11955
0
                                                    returns.extend(Some(v838));
11956
0
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
11957
0
                                                }
11958
0
                                            }
11959
0
                                        }
11960
0
                                    }
11961
                                }
11962
                            }
11963
                            F64 => {
11964
0
                                let mut v34 = C::inst_data_value_etor_returns::default();
11965
0
                                C::inst_data_value_etor(ctx, v33, &mut v34);
11966
0
                                let mut v34 = v34.into_context_iter();
11967
0
                                while let Some(v35) = v34.next(ctx) {
11968
0
                                    if v35.0 == F64 {
11969
                                        if let &InstructionData::UnaryIeee64 {
11970
0
                                            opcode: ref v713,
11971
0
                                            imm: v714,
11972
0
                                        } = &v35.1 {
11973
0
                                            if let &Opcode::F64const = v713 {
11974
0
                                                let v839 = C::f64_nearest(ctx, v714);
11975
0
                                                if let Some(v840) = v839 {
11976
0
                                                    let v841 = constructor_f64const(ctx, F64, v840);
11977
0
                                                    let v842 = C::subsume(ctx, v841);
11978
                                                    // Rule at src/opts/cprop.isle line 365.
11979
0
                                                    returns.extend(Some(v842));
11980
0
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
11981
0
                                                }
11982
0
                                            }
11983
0
                                        }
11984
0
                                    }
11985
                                }
11986
                            }
11987
0
                            _ => {}
11988
                        }
11989
                    }
11990
                    &Opcode::Bmask => {
11991
8
                        if v2.0 == I8 {
11992
0
                            let mut v34 = C::inst_data_value_etor_returns::default();
11993
0
                            C::inst_data_value_etor(ctx, v33, &mut v34);
11994
0
                            let mut v34 = v34.into_context_iter();
11995
0
                            while let Some(v35) = v34.next(ctx) {
11996
0
                                if v35.0 == I8 {
11997
                                    if let &InstructionData::IntCompare {
11998
0
                                        opcode: ref v254,
11999
0
                                        args: ref v255,
12000
0
                                        cond: ref v256,
12001
0
                                    } = &v35.1 {
12002
0
                                        if let &Opcode::Icmp = v254 {
12003
0
                                            let v261 = constructor_ineg(ctx, I8, v33);
12004
                                            // Rule at src/opts/bitops.isle line 97.
12005
0
                                            returns.extend(Some(v261));
12006
0
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
12007
0
                                        }
12008
0
                                    }
12009
0
                                }
12010
                            }
12011
8
                        }
12012
8
                        let mut v262 = ContextIterWrapper::<ConstructorVec<_>, _>::default();
12013
8
                        constructor_truthy(ctx, v33, &mut v262);
12014
8
                        let mut v262 = v262.into_context_iter();
12015
8
                        while let Some(
v2630
) = v262.next(ctx) {
12016
0
                            let v264 = constructor_bmask(ctx, v2.0, v263);
12017
                            // Rule at src/opts/bitops.isle line 119.
12018
0
                            returns.extend(Some(v264));
12019
0
                            if returns.len() >= MAX_ISLE_RETURNS { return; }
12020
                        }
12021
                    }
12022
                    &Opcode::Ireduce => {
12023
19.6k
                        let mut v34 = C::inst_data_value_etor_returns::default();
12024
19.6k
                        C::inst_data_value_etor(ctx, v33, &mut v34);
12025
19.6k
                        let mut v34 = v34.into_context_iter();
12026
38.4k
                        while let Some(
v3518.8k
) = v34.next(ctx) {
12027
18.8k
                            match &v35.1 {
12028
                                &InstructionData::Binary {
12029
9.69k
                                    opcode: ref v38,
12030
9.69k
                                    args: ref v39,
12031
                                } => {
12032
9.69k
                                    match v38 {
12033
                                        &Opcode::Iadd => {
12034
244
                                            let v40 = C::unpack_value_array_2(ctx, v39);
12035
244
                                            let v984 = constructor_ireduce(ctx, v2.0, v40.0);
12036
244
                                            let v985 = constructor_ireduce(ctx, v2.0, v40.1);
12037
244
                                            let v986 = constructor_iadd(ctx, v2.0, v984, v985);
12038
                                            // Rule at src/opts/extends.isle line 85.
12039
244
                                            returns.extend(Some(v986));
12040
244
                                            if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
12041
                                        }
12042
                                        &Opcode::Isub => {
12043
90
                                            let v40 = C::unpack_value_array_2(ctx, v39);
12044
90
                                            let v984 = constructor_ireduce(ctx, v2.0, v40.0);
12045
90
                                            let v985 = constructor_ireduce(ctx, v2.0, v40.1);
12046
90
                                            let v987 = constructor_isub(ctx, v2.0, v984, v985);
12047
                                            // Rule at src/opts/extends.isle line 86.
12048
90
                                            returns.extend(Some(v987));
12049
90
                                            if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
12050
                                        }
12051
                                        &Opcode::Imul => {
12052
2.63k
                                            let v40 = C::unpack_value_array_2(ctx, v39);
12053
2.63k
                                            let v984 = constructor_ireduce(ctx, v2.0, v40.0);
12054
2.63k
                                            let v985 = constructor_ireduce(ctx, v2.0, v40.1);
12055
2.63k
                                            let v988 = constructor_imul(ctx, v2.0, v984, v985);
12056
                                            // Rule at src/opts/extends.isle line 87.
12057
2.63k
                                            returns.extend(Some(v988));
12058
2.63k
                                            if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
12059
                                        }
12060
                                        &Opcode::Band => {
12061
36
                                            let v40 = C::unpack_value_array_2(ctx, v39);
12062
36
                                            let v984 = constructor_ireduce(ctx, v2.0, v40.0);
12063
36
                                            let v985 = constructor_ireduce(ctx, v2.0, v40.1);
12064
36
                                            let v991 = constructor_band(ctx, v2.0, v984, v985);
12065
                                            // Rule at src/opts/extends.isle line 90.
12066
36
                                            returns.extend(Some(v991));
12067
36
                                            if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
12068
                                        }
12069
                                        &Opcode::Bor => {
12070
510
                                            let v40 = C::unpack_value_array_2(ctx, v39);
12071
510
                                            let v984 = constructor_ireduce(ctx, v2.0, v40.0);
12072
510
                                            let v985 = constructor_ireduce(ctx, v2.0, v40.1);
12073
510
                                            let v989 = constructor_bor(ctx, v2.0, v984, v985);
12074
                                            // Rule at src/opts/extends.isle line 88.
12075
510
                                            returns.extend(Some(v989));
12076
510
                                            if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
12077
                                        }
12078
                                        &Opcode::Bxor => {
12079
192
                                            let v40 = C::unpack_value_array_2(ctx, v39);
12080
192
                                            let v984 = constructor_ireduce(ctx, v2.0, v40.0);
12081
192
                                            let v985 = constructor_ireduce(ctx, v2.0, v40.1);
12082
192
                                            let v990 = constructor_bxor(ctx, v2.0, v984, v985);
12083
                                            // Rule at src/opts/extends.isle line 89.
12084
192
                                            returns.extend(Some(v990));
12085
192
                                            if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
12086
                                        }
12087
5.99k
                                        _ => {}
12088
                                    }
12089
                                }
12090
                                &InstructionData::Unary {
12091
3.09k
                                    opcode: ref v45,
12092
3.09k
                                    arg: v46,
12093
                                } => {
12094
3.09k
                                    match v45 {
12095
                                        &Opcode::Ineg => {
12096
0
                                            let v981 = constructor_ireduce(ctx, v2.0, v46);
12097
0
                                            let v982 = constructor_ineg(ctx, v2.0, v981);
12098
                                            // Rule at src/opts/extends.isle line 82.
12099
0
                                            returns.extend(Some(v982));
12100
0
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
12101
                                        }
12102
                                        &Opcode::Bnot => {
12103
0
                                            let v981 = constructor_ireduce(ctx, v2.0, v46);
12104
0
                                            let v983 = constructor_bnot(ctx, v2.0, v981);
12105
                                            // Rule at src/opts/extends.isle line 83.
12106
0
                                            returns.extend(Some(v983));
12107
0
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
12108
                                        }
12109
                                        &Opcode::Bmask => {
12110
0
                                            let v288 = constructor_bmask(ctx, v2.0, v46);
12111
                                            // Rule at src/opts/bitops.isle line 133.
12112
0
                                            returns.extend(Some(v288));
12113
0
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
12114
                                        }
12115
                                        &Opcode::Uextend => {
12116
2.86k
                                            let v52 = C::ty_int(ctx, v2.0);
12117
2.86k
                                            if let Some(v53) = v52 {
12118
2.86k
                                                let v967 = C::ty_bits_u64(ctx, v53);
12119
2.86k
                                                let v966 = C::value_type(ctx, v46);
12120
2.86k
                                                let v968 = C::ty_bits_u64(ctx, v966);
12121
2.86k
                                                let v969 = C::u64_lt(ctx, v967, v968);
12122
2.86k
                                                if v969 == true {
12123
0
                                                    let v970 = constructor_ireduce(ctx, v53, v46);
12124
                                                    // Rule at src/opts/extends.isle line 57.
12125
0
                                                    returns.extend(Some(v970));
12126
0
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
12127
2.86k
                                                }
12128
2.86k
                                                let v971 = C::u64_lt(ctx, v968, v967);
12129
2.86k
                                                if v971 == true {
12130
0
                                                    let v973 = constructor_uextend(ctx, v53, v46);
12131
                                                    // Rule at src/opts/extends.isle line 64.
12132
0
                                                    returns.extend(Some(v973));
12133
0
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
12134
2.86k
                                                }
12135
0
                                            }
12136
2.86k
                                            let v966 = C::value_type(ctx, v46);
12137
2.86k
                                            if v2.0 == v966 {
12138
2.86k
                                                let v47 = C::subsume(ctx, v46);
12139
                                                // Rule at src/opts/extends.isle line 50.
12140
2.86k
                                                returns.extend(Some(v47));
12141
2.86k
                                                if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
12142
0
                                            }
12143
                                        }
12144
                                        &Opcode::Sextend => {
12145
0
                                            let v52 = C::ty_int(ctx, v2.0);
12146
0
                                            if let Some(v53) = v52 {
12147
0
                                                let v967 = C::ty_bits_u64(ctx, v53);
12148
0
                                                let v966 = C::value_type(ctx, v46);
12149
0
                                                let v968 = C::ty_bits_u64(ctx, v966);
12150
0
                                                let v969 = C::u64_lt(ctx, v967, v968);
12151
0
                                                if v969 == true {
12152
0
                                                    let v970 = constructor_ireduce(ctx, v53, v46);
12153
                                                    // Rule at src/opts/extends.isle line 54.
12154
0
                                                    returns.extend(Some(v970));
12155
0
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
12156
0
                                                }
12157
0
                                                let v971 = C::u64_lt(ctx, v968, v967);
12158
0
                                                if v971 == true {
12159
0
                                                    let v972 = constructor_sextend(ctx, v53, v46);
12160
                                                    // Rule at src/opts/extends.isle line 61.
12161
0
                                                    returns.extend(Some(v972));
12162
0
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
12163
0
                                                }
12164
0
                                            }
12165
0
                                            let v966 = C::value_type(ctx, v46);
12166
0
                                            if v2.0 == v966 {
12167
0
                                                let v47 = C::subsume(ctx, v46);
12168
                                                // Rule at src/opts/extends.isle line 49.
12169
0
                                                returns.extend(Some(v47));
12170
0
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
12171
0
                                            }
12172
                                        }
12173
226
                                        _ => {}
12174
                                    }
12175
                                }
12176
                                &InstructionData::UnaryImm {
12177
2.00k
                                    opcode: ref v567,
12178
2.00k
                                    imm: v568,
12179
                                } => {
12180
2.00k
                                    if let &Opcode::Iconst = v567 {
12181
2.00k
                                        let v583 = C::fits_in_64(ctx, v35.0);
12182
2.00k
                                        if let Some(v584) = v583 {
12183
2.00k
                                            let v569 = C::u64_from_imm64(ctx, v568);
12184
2.00k
                                            let v585 = C::imm64_masked(ctx, v2.0, v569);
12185
2.00k
                                            let v586 = constructor_iconst(ctx, v2.0, v585);
12186
2.00k
                                            let v587 = C::subsume(ctx, v586);
12187
                                            // Rule at src/opts/cprop.isle line 70.
12188
2.00k
                                            returns.extend(Some(v587));
12189
2.00k
                                            if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
12190
0
                                        }
12191
0
                                    }
12192
                                }
12193
4.03k
                                _ => {}
12194
                            }
12195
                        }
12196
                    }
12197
                    &Opcode::SwidenLow => {
12198
0
                        let mut v34 = C::inst_data_value_etor_returns::default();
12199
0
                        C::inst_data_value_etor(ctx, v33, &mut v34);
12200
0
                        let mut v34 = v34.into_context_iter();
12201
0
                        while let Some(v35) = v34.next(ctx) {
12202
                            if let &InstructionData::Unary {
12203
0
                                opcode: ref v45,
12204
0
                                arg: v46,
12205
0
                            } = &v35.1 {
12206
0
                                if let &Opcode::Splat = v45 {
12207
0
                                    let v1262 = C::lane_type(ctx, v2.0);
12208
0
                                    let v1424 = constructor_sextend(ctx, v1262, v46);
12209
0
                                    let v1425 = constructor_splat(ctx, v2.0, v1424);
12210
                                    // Rule at src/opts/vector.isle line 85.
12211
0
                                    returns.extend(Some(v1425));
12212
0
                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
12213
0
                                }
12214
0
                            }
12215
                        }
12216
                    }
12217
                    &Opcode::SwidenHigh => {
12218
0
                        let mut v34 = C::inst_data_value_etor_returns::default();
12219
0
                        C::inst_data_value_etor(ctx, v33, &mut v34);
12220
0
                        let mut v34 = v34.into_context_iter();
12221
0
                        while let Some(v35) = v34.next(ctx) {
12222
                            if let &InstructionData::Unary {
12223
0
                                opcode: ref v45,
12224
0
                                arg: v46,
12225
0
                            } = &v35.1 {
12226
0
                                if let &Opcode::Splat = v45 {
12227
0
                                    let v1262 = C::lane_type(ctx, v2.0);
12228
0
                                    let v1424 = constructor_sextend(ctx, v1262, v46);
12229
0
                                    let v1425 = constructor_splat(ctx, v2.0, v1424);
12230
                                    // Rule at src/opts/vector.isle line 84.
12231
0
                                    returns.extend(Some(v1425));
12232
0
                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
12233
0
                                }
12234
0
                            }
12235
                        }
12236
                    }
12237
                    &Opcode::UwidenLow => {
12238
0
                        let mut v34 = C::inst_data_value_etor_returns::default();
12239
0
                        C::inst_data_value_etor(ctx, v33, &mut v34);
12240
0
                        let mut v34 = v34.into_context_iter();
12241
0
                        while let Some(v35) = v34.next(ctx) {
12242
                            if let &InstructionData::Unary {
12243
0
                                opcode: ref v45,
12244
0
                                arg: v46,
12245
0
                            } = &v35.1 {
12246
0
                                if let &Opcode::Splat = v45 {
12247
0
                                    let v1262 = C::lane_type(ctx, v2.0);
12248
0
                                    let v1426 = constructor_uextend(ctx, v1262, v46);
12249
0
                                    let v1427 = constructor_splat(ctx, v2.0, v1426);
12250
                                    // Rule at src/opts/vector.isle line 88.
12251
0
                                    returns.extend(Some(v1427));
12252
0
                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
12253
0
                                }
12254
0
                            }
12255
                        }
12256
                    }
12257
                    &Opcode::UwidenHigh => {
12258
0
                        let mut v34 = C::inst_data_value_etor_returns::default();
12259
0
                        C::inst_data_value_etor(ctx, v33, &mut v34);
12260
0
                        let mut v34 = v34.into_context_iter();
12261
0
                        while let Some(v35) = v34.next(ctx) {
12262
                            if let &InstructionData::Unary {
12263
0
                                opcode: ref v45,
12264
0
                                arg: v46,
12265
0
                            } = &v35.1 {
12266
0
                                if let &Opcode::Splat = v45 {
12267
0
                                    let v1262 = C::lane_type(ctx, v2.0);
12268
0
                                    let v1426 = constructor_uextend(ctx, v1262, v46);
12269
0
                                    let v1427 = constructor_splat(ctx, v2.0, v1426);
12270
                                    // Rule at src/opts/vector.isle line 87.
12271
0
                                    returns.extend(Some(v1427));
12272
0
                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
12273
0
                                }
12274
0
                            }
12275
                        }
12276
                    }
12277
                    &Opcode::Uextend => {
12278
867k
                        let mut v34 = C::inst_data_value_etor_returns::default();
12279
867k
                        C::inst_data_value_etor(ctx, v33, &mut v34);
12280
867k
                        let mut v34 = v34.into_context_iter();
12281
1.82M
                        while let Some(
v35953k
) = v34.next(ctx) {
12282
953k
                            match &v35.1 {
12283
                                &InstructionData::Unary {
12284
4.55k
                                    opcode: ref v45,
12285
4.55k
                                    arg: v46,
12286
                                } => {
12287
4.55k
                                    if let &Opcode::Uextend = v45 {
12288
4.18k
                                        let v936 = constructor_uextend(ctx, v2.0, v46);
12289
                                        // Rule at src/opts/extends.isle line 1.
12290
4.18k
                                        returns.extend(Some(v936));
12291
4.18k
                                        if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
12292
368
                                    }
12293
                                }
12294
                                &InstructionData::UnaryImm {
12295
12.2k
                                    opcode: ref v567,
12296
12.2k
                                    imm: v568,
12297
                                } => {
12298
12.2k
                                    if let &Opcode::Iconst = v567 {
12299
12.2k
                                        let v541 = C::fits_in_64(ctx, v2.0);
12300
12.2k
                                        if let Some(v542) = v541 {
12301
12.2k
                                            let v569 = C::u64_from_imm64(ctx, v568);
12302
12.2k
                                            let v588 = constructor_iconst_u(ctx, v542, v569);
12303
12.2k
                                            let v589 = C::subsume(ctx, v588);
12304
                                            // Rule at src/opts/cprop.isle line 75.
12305
12.2k
                                            returns.extend(Some(v589));
12306
12.2k
                                            if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
12307
0
                                        }
12308
0
                                    }
12309
                                }
12310
936k
                                _ => {}
12311
                            }
12312
                        }
12313
                    }
12314
                    &Opcode::Sextend => {
12315
530
                        let mut v34 = C::inst_data_value_etor_returns::default();
12316
530
                        C::inst_data_value_etor(ctx, v33, &mut v34);
12317
530
                        let mut v34 = v34.into_context_iter();
12318
1.09k
                        while let Some(
v35563
) = v34.next(ctx) {
12319
563
                            match &v35.1 {
12320
                                &InstructionData::IntCompare {
12321
0
                                    opcode: ref v254,
12322
0
                                    args: ref v255,
12323
0
                                    cond: ref v256,
12324
                                } => {
12325
0
                                    if let &Opcode::Icmp = v254 {
12326
0
                                        let v938 = constructor_uextend(ctx, v2.0, v33);
12327
                                        // Rule at src/opts/extends.isle line 11.
12328
0
                                        returns.extend(Some(v938));
12329
0
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
12330
0
                                    }
12331
                                }
12332
                                &InstructionData::Unary {
12333
137
                                    opcode: ref v45,
12334
137
                                    arg: v46,
12335
                                } => {
12336
137
                                    match v45 {
12337
                                        &Opcode::Bmask => {
12338
0
                                            let v288 = constructor_bmask(ctx, v2.0, v46);
12339
                                            // Rule at src/opts/bitops.isle line 132.
12340
0
                                            returns.extend(Some(v288));
12341
0
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
12342
                                        }
12343
                                        &Opcode::Uextend => {
12344
0
                                            let v936 = constructor_uextend(ctx, v2.0, v46);
12345
                                            // Rule at src/opts/extends.isle line 7.
12346
0
                                            returns.extend(Some(v936));
12347
0
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
12348
                                        }
12349
                                        &Opcode::Sextend => {
12350
0
                                            let v937 = constructor_sextend(ctx, v2.0, v46);
12351
                                            // Rule at src/opts/extends.isle line 3.
12352
0
                                            returns.extend(Some(v937));
12353
0
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
12354
                                        }
12355
137
                                        _ => {}
12356
                                    }
12357
                                }
12358
426
                                _ => {}
12359
                            }
12360
                        }
12361
530
                        let v541 = C::fits_in_64(ctx, v2.0);
12362
530
                        if let Some(v542) = v541 {
12363
530
                            let mut v590 = C::inst_data_value_tupled_etor_returns::default();
12364
530
                            C::inst_data_value_tupled_etor(ctx, v33, &mut v590);
12365
530
                            let mut v590 = v590.into_context_iter();
12366
1.09k
                            while let Some(
v591563
) = v590.next(ctx) {
12367
563
                                let v592 = C::iconst_sextend_etor(ctx, v591);
12368
563
                                if let Some(
v5930
) = v592 {
12369
0
                                    let v596 = constructor_iconst_s(ctx, v542, v593.1);
12370
0
                                    let v597 = C::subsume(ctx, v596);
12371
                                    // Rule at src/opts/cprop.isle line 77.
12372
0
                                    returns.extend(Some(v597));
12373
0
                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
12374
563
                                }
12375
                            }
12376
0
                        }
12377
                    }
12378
                    &Opcode::FcvtFromUint => {
12379
0
                        let mut v34 = C::inst_data_value_etor_returns::default();
12380
0
                        C::inst_data_value_etor(ctx, v33, &mut v34);
12381
0
                        let mut v34 = v34.into_context_iter();
12382
0
                        while let Some(v35) = v34.next(ctx) {
12383
0
                            match &v35.1 {
12384
                                &InstructionData::Unary {
12385
0
                                    opcode: ref v45,
12386
0
                                    arg: v46,
12387
                                } => {
12388
0
                                    match v45 {
12389
                                        &Opcode::Splat => {
12390
0
                                            let v1262 = C::lane_type(ctx, v2.0);
12391
0
                                            let v1376 = constructor_fcvt_from_uint(ctx, v1262, v46);
12392
0
                                            let v1377 = constructor_splat(ctx, v2.0, v1376);
12393
                                            // Rule at src/opts/vector.isle line 6.
12394
0
                                            returns.extend(Some(v1377));
12395
0
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
12396
                                        }
12397
                                        &Opcode::Uextend => {
12398
0
                                            let v215 = constructor_fcvt_from_uint(ctx, v2.0, v46);
12399
                                            // Rule at src/opts/arithmetic.isle line 314.
12400
0
                                            returns.extend(Some(v215));
12401
0
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
12402
                                        }
12403
0
                                        _ => {}
12404
                                    }
12405
                                }
12406
                                &InstructionData::UnaryImm {
12407
0
                                    opcode: ref v567,
12408
0
                                    imm: v568,
12409
                                } => {
12410
0
                                    if let &Opcode::Iconst = v567 {
12411
0
                                        match v2.0 {
12412
                                            F32 => {
12413
0
                                                let v569 = C::u64_from_imm64(ctx, v568);
12414
0
                                                let v742 = C::f32_from_uint(ctx, v569);
12415
0
                                                let v743 = constructor_f32const(ctx, F32, v742);
12416
                                                // Rule at src/opts/cprop.isle line 264.
12417
0
                                                returns.extend(Some(v743));
12418
0
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
12419
                                            }
12420
                                            F64 => {
12421
0
                                                let v569 = C::u64_from_imm64(ctx, v568);
12422
0
                                                let v745 = C::f64_from_uint(ctx, v569);
12423
0
                                                let v746 = constructor_f64const(ctx, F64, v745);
12424
                                                // Rule at src/opts/cprop.isle line 266.
12425
0
                                                returns.extend(Some(v746));
12426
0
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
12427
                                            }
12428
0
                                            _ => {}
12429
                                        }
12430
0
                                    }
12431
                                }
12432
0
                                _ => {}
12433
                            }
12434
                        }
12435
                    }
12436
                    &Opcode::FcvtFromSint => {
12437
0
                        match v2.0 {
12438
                            F32 => {
12439
0
                                let mut v590 = C::inst_data_value_tupled_etor_returns::default();
12440
0
                                C::inst_data_value_tupled_etor(ctx, v33, &mut v590);
12441
0
                                let mut v590 = v590.into_context_iter();
12442
0
                                while let Some(v591) = v590.next(ctx) {
12443
0
                                    let v592 = C::iconst_sextend_etor(ctx, v591);
12444
0
                                    if let Some(v593) = v592 {
12445
0
                                        let v747 = C::f32_from_sint(ctx, v593.1);
12446
0
                                        let v748 = constructor_f32const(ctx, F32, v747);
12447
                                        // Rule at src/opts/cprop.isle line 268.
12448
0
                                        returns.extend(Some(v748));
12449
0
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
12450
0
                                    }
12451
                                }
12452
                            }
12453
                            F64 => {
12454
0
                                let mut v590 = C::inst_data_value_tupled_etor_returns::default();
12455
0
                                C::inst_data_value_tupled_etor(ctx, v33, &mut v590);
12456
0
                                let mut v590 = v590.into_context_iter();
12457
0
                                while let Some(v591) = v590.next(ctx) {
12458
0
                                    let v592 = C::iconst_sextend_etor(ctx, v591);
12459
0
                                    if let Some(v593) = v592 {
12460
0
                                        let v749 = C::f64_from_sint(ctx, v593.1);
12461
0
                                        let v750 = constructor_f64const(ctx, F64, v749);
12462
                                        // Rule at src/opts/cprop.isle line 270.
12463
0
                                        returns.extend(Some(v750));
12464
0
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
12465
0
                                    }
12466
                                }
12467
                            }
12468
0
                            _ => {}
12469
                        }
12470
0
                        let mut v34 = C::inst_data_value_etor_returns::default();
12471
0
                        C::inst_data_value_etor(ctx, v33, &mut v34);
12472
0
                        let mut v34 = v34.into_context_iter();
12473
0
                        while let Some(v35) = v34.next(ctx) {
12474
                            if let &InstructionData::Unary {
12475
0
                                opcode: ref v45,
12476
0
                                arg: v46,
12477
0
                            } = &v35.1 {
12478
0
                                match v45 {
12479
                                    &Opcode::Splat => {
12480
0
                                        let v1262 = C::lane_type(ctx, v2.0);
12481
0
                                        let v1378 = constructor_fcvt_from_sint(ctx, v1262, v46);
12482
0
                                        let v1379 = constructor_splat(ctx, v2.0, v1378);
12483
                                        // Rule at src/opts/vector.isle line 8.
12484
0
                                        returns.extend(Some(v1379));
12485
0
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
12486
                                    }
12487
                                    &Opcode::Sextend => {
12488
0
                                        let v216 = constructor_fcvt_from_sint(ctx, v2.0, v46);
12489
                                        // Rule at src/opts/arithmetic.isle line 316.
12490
0
                                        returns.extend(Some(v216));
12491
0
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
12492
                                    }
12493
0
                                    _ => {}
12494
                                }
12495
0
                            }
12496
                        }
12497
                    }
12498
470
                    _ => {}
12499
                }
12500
            }
12501
            &InstructionData::UnaryIeee32 {
12502
0
                opcode: ref v1145,
12503
0
                imm: v1146,
12504
            } => {
12505
0
                if let &Opcode::F32const = v1145 {
12506
0
                    let v1142 = C::remat(ctx, arg0);
12507
                    // Rule at src/opts/remat.isle line 27.
12508
0
                    returns.extend(Some(v1142));
12509
0
                    if returns.len() >= MAX_ISLE_RETURNS { return; }
12510
0
                }
12511
            }
12512
            &InstructionData::UnaryIeee64 {
12513
0
                opcode: ref v1147,
12514
0
                imm: v1148,
12515
            } => {
12516
0
                if let &Opcode::F64const = v1147 {
12517
0
                    let v1142 = C::remat(ctx, arg0);
12518
                    // Rule at src/opts/remat.isle line 29.
12519
0
                    returns.extend(Some(v1142));
12520
0
                    if returns.len() >= MAX_ISLE_RETURNS { return; }
12521
0
                }
12522
            }
12523
            &InstructionData::UnaryImm {
12524
1.00M
                opcode: ref v1143,
12525
1.00M
                imm: v1144,
12526
            } => {
12527
1.00M
                if let &Opcode::Iconst = v1143 {
12528
1.00M
                    let v1142 = C::remat(ctx, arg0);
12529
                    // Rule at src/opts/remat.isle line 25.
12530
1.00M
                    returns.extend(Some(v1142));
12531
1.00M
                    if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
12532
0
                }
12533
            }
12534
80.0k
            _ => {}
12535
        }
12536
    }
12537
5.42M
}
12538
12539
// Generated as internal constructor for term inst_to_skeleton_inst_simplification.
12540
0
pub fn constructor_inst_to_skeleton_inst_simplification<C: Context>(
12541
0
    ctx: &mut C,
12542
0
    arg0: Inst,
12543
0
) -> SkeletonInstSimplification {
12544
0
    let v1 = SkeletonInstSimplification::Replace {
12545
0
        inst: arg0,
12546
0
    };
12547
    // Rule at src/prelude_opt.isle line 91.
12548
0
    return v1;
12549
0
}
12550
12551
// Generated as internal constructor for term value_to_skeleton_inst_simplification.
12552
3.75k
pub fn constructor_value_to_skeleton_inst_simplification<C: Context>(
12553
3.75k
    ctx: &mut C,
12554
3.75k
    arg0: Value,
12555
3.75k
) -> SkeletonInstSimplification {
12556
3.75k
    let v1 = SkeletonInstSimplification::RemoveWithVal {
12557
3.75k
        val: arg0,
12558
3.75k
    };
12559
    // Rule at src/prelude_opt.isle line 95.
12560
3.75k
    return v1;
12561
3.75k
}
12562
12563
// Generated as internal constructor for term remove_inst.
12564
0
pub fn constructor_remove_inst<C: Context>(
12565
0
    ctx: &mut C,
12566
0
) -> SkeletonInstSimplification {
12567
    // Rule at src/prelude_opt.isle line 99.
12568
0
    return SkeletonInstSimplification::Remove;
12569
0
}
12570
12571
// Generated as internal constructor for term replace_with_val.
12572
0
pub fn constructor_replace_with_val<C: Context>(
12573
0
    ctx: &mut C,
12574
0
    arg0: Inst,
12575
0
    arg1: Value,
12576
0
) -> SkeletonInstSimplification {
12577
0
    let v2 = SkeletonInstSimplification::ReplaceWithVal {
12578
0
        inst: arg0,
12579
0
        val: arg1,
12580
0
    };
12581
    // Rule at src/prelude_opt.isle line 102.
12582
0
    return v2;
12583
0
}
12584
12585
// Generated as internal constructor for term simplify_skeleton.
12586
2.36M
pub fn constructor_simplify_skeleton<C: Context>(
12587
2.36M
    ctx: &mut C,
12588
2.36M
    arg0: Inst,
12589
2.36M
    returns: &mut (impl Extend<SkeletonInstSimplification> + Length),
12590
2.36M
) -> () {
12591
2.36M
    let v1 = &C::inst_data_etor(ctx, arg0);
12592
2.36M
    if let Some(v2) = v1 {
12593
2.36M
        match v2 {
12594
            &InstructionData::Binary {
12595
4.30k
                opcode: ref v3,
12596
4.30k
                args: ref v4,
12597
            } => {
12598
4.30k
                match v3 {
12599
                    &Opcode::Udiv => {
12600
3.09k
                        let v5 = C::unpack_value_array_2(ctx, v4);
12601
3.09k
                        let mut v15 = C::inst_data_value_etor_returns::default();
12602
3.09k
                        C::inst_data_value_etor(ctx, v5.1, &mut v15);
12603
3.09k
                        let mut v15 = v15.into_context_iter();
12604
6.16k
                        while let Some(
v163.07k
) = v15.next(ctx) {
12605
3.07k
                            match &v16.1 {
12606
                                &InstructionData::Ternary {
12607
172
                                    opcode: ref v178,
12608
172
                                    args: ref v179,
12609
                                } => {
12610
172
                                    if let &Opcode::Select = v178 {
12611
172
                                        let v180 = C::unpack_value_array_3(ctx, v179);
12612
172
                                        let mut v184 = C::inst_data_value_etor_returns::default();
12613
172
                                        C::inst_data_value_etor(ctx, v180.1, &mut v184);
12614
172
                                        let mut v184 = v184.into_context_iter();
12615
344
                                        while let Some(
v185172
) = v184.next(ctx) {
12616
                                            if let &InstructionData::UnaryImm {
12617
2
                                                opcode: ref v188,
12618
2
                                                imm: v189,
12619
172
                                            } = &v185.1 {
12620
2
                                                if let &Opcode::Iconst = v188 {
12621
2
                                                    let v190 = C::imm64_power_of_two(ctx, v189);
12622
2
                                                    if let Some(v191) = v190 {
12623
2
                                                        if v16.0 == v185.0 {
12624
2
                                                            let mut v192 = C::inst_data_value_etor_returns::default();
12625
2
                                                            C::inst_data_value_etor(ctx, v180.2, &mut v192);
12626
2
                                                            let mut v192 = v192.into_context_iter();
12627
4
                                                            while let Some(
v1932
) = v192.next(ctx) {
12628
                                                                if let &InstructionData::UnaryImm {
12629
0
                                                                    opcode: ref v196,
12630
0
                                                                    imm: v197,
12631
2
                                                                } = &v193.1 {
12632
0
                                                                    if let &Opcode::Iconst = v196 {
12633
0
                                                                        let v198 = C::imm64_power_of_two(ctx, v197);
12634
0
                                                                        if let Some(v199) = v198 {
12635
0
                                                                            if v16.0 == v193.0 {
12636
0
                                                                                let v200 = C::imm64(ctx, v191);
12637
0
                                                                                let v201 = constructor_iconst(ctx, v16.0, v200);
12638
0
                                                                                let v202 = C::imm64(ctx, v199);
12639
0
                                                                                let v203 = constructor_iconst(ctx, v16.0, v202);
12640
0
                                                                                let v204 = constructor_select(ctx, v16.0, v180.0, v201, v203);
12641
0
                                                                                let v205 = constructor_ushr(ctx, v16.0, v5.0, v204);
12642
0
                                                                                let v206 = &constructor_value_to_skeleton_inst_simplification(ctx, v205);
12643
                                                                                // Rule at src/opts/skeleton.isle line 40.
12644
0
                                                                                returns.extend(Some(v206.clone()));
12645
0
                                                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
12646
0
                                                                            }
12647
0
                                                                        }
12648
0
                                                                    }
12649
2
                                                                }
12650
                                                            }
12651
0
                                                        }
12652
0
                                                    }
12653
0
                                                }
12654
170
                                            }
12655
                                        }
12656
0
                                    }
12657
                                }
12658
                                &InstructionData::UnaryImm {
12659
2.70k
                                    opcode: ref v19,
12660
2.70k
                                    imm: v20,
12661
                                } => {
12662
2.70k
                                    if let &Opcode::Iconst = v19 {
12663
2.70k
                                        match v16.0 {
12664
                                            I32 => {
12665
2.16k
                                                let v21 = C::u64_from_imm64(ctx, v20);
12666
2.16k
                                                let v68 = C::u64_matches_non_zero(ctx, v21);
12667
2.16k
                                                if let Some(v69) = v68 {
12668
2.16k
                                                    if v69 == true {
12669
2.16k
                                                        let v70 = C::u64_from_u32(ctx, v21);
12670
2.16k
                                                        if let Some(v71) = v70 {
12671
2.16k
                                                            let v72 = C::u32_is_power_of_two(ctx, v71);
12672
2.16k
                                                            if v72 == false {
12673
2.16k
                                                                let v74 = constructor_apply_div_const_magic_u32(ctx, &Opcode::Udiv, v5.0, v71);
12674
2.16k
                                                                let v75 = &constructor_value_to_skeleton_inst_simplification(ctx, v74);
12675
                                                                // Rule at src/opts/arithmetic.isle line 109.
12676
2.16k
                                                                returns.extend(Some(v75.clone()));
12677
2.16k
                                                                if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
12678
0
                                                            }
12679
0
                                                        }
12680
0
                                                    }
12681
0
                                                }
12682
                                            }
12683
                                            I64 => {
12684
535
                                                let v21 = C::u64_from_imm64(ctx, v20);
12685
535
                                                let v68 = C::u64_matches_non_zero(ctx, v21);
12686
535
                                                if let Some(v69) = v68 {
12687
535
                                                    if v69 == true {
12688
535
                                                        let v76 = C::u64_is_power_of_two(ctx, v21);
12689
535
                                                        if v76 == false {
12690
535
                                                            let v77 = constructor_apply_div_const_magic_u64(ctx, &Opcode::Udiv, v5.0, v21);
12691
535
                                                            let v78 = &constructor_value_to_skeleton_inst_simplification(ctx, v77);
12692
                                                            // Rule at src/opts/arithmetic.isle line 112.
12693
535
                                                            returns.extend(Some(v78.clone()));
12694
535
                                                            if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
12695
0
                                                        }
12696
0
                                                    }
12697
0
                                                }
12698
                                            }
12699
0
                                            _ => {}
12700
                                        }
12701
2.70k
                                        let v21 = C::u64_from_imm64(ctx, v20);
12702
2.70k
                                        if v21 == 0x1_u64 {
12703
0
                                            let v14 = &constructor_value_to_skeleton_inst_simplification(ctx, v5.0);
12704
                                            // Rule at src/opts/arithmetic.isle line 79.
12705
0
                                            returns.extend(Some(v14.clone()));
12706
0
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
12707
2.70k
                                        }
12708
2.70k
                                        let v22 = C::u64_matches_power_of_two(ctx, v21);
12709
2.70k
                                        if let Some(v23) = v22 {
12710
2.70k
                                            if v23 == true {
12711
0
                                                let v24 = C::u64_ilog2(ctx, v21);
12712
0
                                                let v25 = C::u32_into_u64(ctx, v24);
12713
0
                                                let v26 = constructor_iconst_u(ctx, v16.0, v25);
12714
0
                                                let v27 = constructor_ushr(ctx, v16.0, v5.0, v26);
12715
0
                                                let v28 = &constructor_value_to_skeleton_inst_simplification(ctx, v27);
12716
                                                // Rule at src/opts/arithmetic.isle line 82.
12717
0
                                                returns.extend(Some(v28.clone()));
12718
0
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
12719
2.70k
                                            }
12720
0
                                        }
12721
2.70k
                                        let mut v119 = C::inst_data_value_etor_returns::default();
12722
2.70k
                                        C::inst_data_value_etor(ctx, v5.0, &mut v119);
12723
2.70k
                                        let mut v119 = v119.into_context_iter();
12724
6.05k
                                        while let Some(
v1203.35k
) = v119.next(ctx) {
12725
                                            if let &InstructionData::UnaryImm {
12726
0
                                                opcode: ref v123,
12727
0
                                                imm: v124,
12728
3.35k
                                            } = &v120.1 {
12729
0
                                                if let &Opcode::Iconst = v123 {
12730
0
                                                    let v129 = C::u64_from_imm64(ctx, v124);
12731
0
                                                    let v130 = C::u64_checked_div(ctx, v129, v21);
12732
0
                                                    if let Some(v131) = v130 {
12733
0
                                                        if v16.0 == v120.0 {
12734
0
                                                            let v132 = C::imm64_masked(ctx, v120.0, v131);
12735
0
                                                            let v133 = constructor_iconst(ctx, v120.0, v132);
12736
0
                                                            let v134 = &constructor_value_to_skeleton_inst_simplification(ctx, v133);
12737
                                                            // Rule at src/opts/cprop.isle line 26.
12738
0
                                                            returns.extend(Some(v134.clone()));
12739
0
                                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
12740
0
                                                        }
12741
0
                                                    }
12742
0
                                                }
12743
3.35k
                                            }
12744
                                        }
12745
0
                                    }
12746
                                }
12747
201
                                _ => {}
12748
                            }
12749
                        }
12750
                    }
12751
                    &Opcode::Sdiv => {
12752
501
                        let v5 = C::unpack_value_array_2(ctx, v4);
12753
501
                        let mut v8 = C::inst_data_value_tupled_etor_returns::default();
12754
501
                        C::inst_data_value_tupled_etor(ctx, v5.1, &mut v8);
12755
501
                        let mut v8 = v8.into_context_iter();
12756
1.00k
                        while let Some(
v9501
) = v8.next(ctx) {
12757
501
                            let v10 = C::iconst_sextend_etor(ctx, v9);
12758
501
                            if let Some(v11) = v10 {
12759
501
                                match v11.0 {
12760
                                    I32 => {
12761
501
                                        let v79 = C::i64_matches_non_zero(ctx, v11.1);
12762
501
                                        if let Some(v80) = v79 {
12763
501
                                            if v80 == true {
12764
501
                                                let v81 = C::i64_from_i32(ctx, v11.1);
12765
501
                                                if let Some(v82) = v81 {
12766
501
                                                    let v83 = C::i32_into_i64(ctx, v82);
12767
501
                                                    let v84 = constructor_i64_is_any_sign_power_of_two(ctx, v83);
12768
501
                                                    if v84 == false {
12769
501
                                                        let v86 = constructor_apply_div_const_magic_s32(ctx, &Opcode::Sdiv, v5.0, v82);
12770
501
                                                        let v87 = &constructor_value_to_skeleton_inst_simplification(ctx, v86);
12771
                                                        // Rule at src/opts/arithmetic.isle line 117.
12772
501
                                                        returns.extend(Some(v87.clone()));
12773
501
                                                        if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
12774
0
                                                    }
12775
0
                                                }
12776
0
                                            }
12777
0
                                        }
12778
                                    }
12779
                                    I64 => {
12780
0
                                        let v79 = C::i64_matches_non_zero(ctx, v11.1);
12781
0
                                        if let Some(v80) = v79 {
12782
0
                                            if v80 == true {
12783
0
                                                let v88 = constructor_i64_is_any_sign_power_of_two(ctx, v11.1);
12784
0
                                                if v88 == false {
12785
0
                                                    let v89 = constructor_apply_div_const_magic_s64(ctx, &Opcode::Sdiv, v5.0, v11.1);
12786
0
                                                    let v90 = &constructor_value_to_skeleton_inst_simplification(ctx, v89);
12787
                                                    // Rule at src/opts/arithmetic.isle line 120.
12788
0
                                                    returns.extend(Some(v90.clone()));
12789
0
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
12790
0
                                                }
12791
0
                                            }
12792
0
                                        }
12793
                                    }
12794
0
                                    _ => {}
12795
                                }
12796
501
                                if v11.1 == 1_i64 {
12797
0
                                    let v14 = &constructor_value_to_skeleton_inst_simplification(ctx, v5.0);
12798
                                    // Rule at src/opts/arithmetic.isle line 78.
12799
0
                                    returns.extend(Some(v14.clone()));
12800
0
                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
12801
501
                                }
12802
501
                                let v48 = constructor_i64_is_negative_power_of_two(ctx, v11.1);
12803
501
                                if v48 == true {
12804
0
                                    let v50 = C::i64_ne(ctx, v11.1, -1_i64);
12805
0
                                    if v50 == true {
12806
0
                                        let v51 = C::i64_trailing_zeros(ctx, v11.1);
12807
0
                                        let v52 = C::u32_sub(ctx, v51, 0x1_u32);
12808
0
                                        let v53 = C::u32_into_u64(ctx, v52);
12809
0
                                        let v54 = constructor_iconst_u(ctx, v11.0, v53);
12810
0
                                        let v55 = constructor_sshr(ctx, v11.0, v5.0, v54);
12811
0
                                        let v56 = C::ty_bits(ctx, v11.0);
12812
0
                                        let v57 = C::u8_into_u32(ctx, v56);
12813
0
                                        let v58 = C::u32_sub(ctx, v57, v51);
12814
0
                                        let v59 = C::u32_into_u64(ctx, v58);
12815
0
                                        let v60 = constructor_iconst_u(ctx, v11.0, v59);
12816
0
                                        let v61 = constructor_ushr(ctx, v11.0, v55, v60);
12817
0
                                        let v62 = constructor_iadd(ctx, v11.0, v5.0, v61);
12818
0
                                        let v63 = C::u32_into_i64(ctx, v51);
12819
0
                                        let v64 = constructor_iconst_s(ctx, v11.0, v63);
12820
0
                                        let v65 = constructor_sshr(ctx, v11.0, v62, v64);
12821
0
                                        let v66 = constructor_ineg(ctx, v11.0, v65);
12822
0
                                        let v67 = &constructor_value_to_skeleton_inst_simplification(ctx, v66);
12823
                                        // Rule at src/opts/arithmetic.isle line 97.
12824
0
                                        returns.extend(Some(v67.clone()));
12825
0
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
12826
0
                                    }
12827
501
                                }
12828
0
                            }
12829
                        }
12830
501
                        let mut v15 = C::inst_data_value_etor_returns::default();
12831
501
                        C::inst_data_value_etor(ctx, v5.1, &mut v15);
12832
501
                        let mut v15 = v15.into_context_iter();
12833
1.00k
                        while let Some(
v16501
) = v15.next(ctx) {
12834
                            if let &InstructionData::UnaryImm {
12835
501
                                opcode: ref v19,
12836
501
                                imm: v20,
12837
501
                            } = &v16.1 {
12838
501
                                if let &Opcode::Iconst = v19 {
12839
501
                                    let v21 = C::u64_from_imm64(ctx, v20);
12840
501
                                    let v22 = C::u64_matches_power_of_two(ctx, v21);
12841
501
                                    if let Some(v23) = v22 {
12842
501
                                        if v23 == true {
12843
0
                                            let v30 = C::u64_gt(ctx, v21, 0x1_u64);
12844
0
                                            if v30 == true {
12845
0
                                                let v31 = C::u64_trailing_zeros(ctx, v21);
12846
0
                                                let v33 = C::u32_sub(ctx, v31, 0x1_u32);
12847
0
                                                let v34 = C::u32_into_u64(ctx, v33);
12848
0
                                                let v35 = constructor_iconst_u(ctx, v16.0, v34);
12849
0
                                                let v36 = constructor_sshr(ctx, v16.0, v5.0, v35);
12850
0
                                                let v37 = C::ty_bits(ctx, v16.0);
12851
0
                                                let v38 = C::u8_into_u32(ctx, v37);
12852
0
                                                let v39 = C::u32_sub(ctx, v38, v31);
12853
0
                                                let v40 = C::u32_into_u64(ctx, v39);
12854
0
                                                let v41 = constructor_iconst_u(ctx, v16.0, v40);
12855
0
                                                let v42 = constructor_ushr(ctx, v16.0, v36, v41);
12856
0
                                                let v43 = constructor_iadd(ctx, v16.0, v5.0, v42);
12857
0
                                                let v44 = C::u32_into_i64(ctx, v31);
12858
0
                                                let v45 = constructor_iconst_s(ctx, v16.0, v44);
12859
0
                                                let v46 = constructor_sshr(ctx, v16.0, v43, v45);
12860
0
                                                let v47 = &constructor_value_to_skeleton_inst_simplification(ctx, v46);
12861
                                                // Rule at src/opts/arithmetic.isle line 86.
12862
0
                                                returns.extend(Some(v47.clone()));
12863
0
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
12864
0
                                            }
12865
501
                                        }
12866
0
                                    }
12867
501
                                    let mut v119 = C::inst_data_value_etor_returns::default();
12868
501
                                    C::inst_data_value_etor(ctx, v5.0, &mut v119);
12869
501
                                    let mut v119 = v119.into_context_iter();
12870
1.00k
                                    while let Some(
v120502
) = v119.next(ctx) {
12871
                                        if let &InstructionData::UnaryImm {
12872
2
                                            opcode: ref v123,
12873
2
                                            imm: v124,
12874
502
                                        } = &v120.1 {
12875
2
                                            if let &Opcode::Iconst = v123 {
12876
2
                                                let v125 = C::imm64_sdiv(ctx, v120.0, v124, v20);
12877
2
                                                if let Some(v126) = v125 {
12878
2
                                                    let v127 = constructor_iconst(ctx, v120.0, v126);
12879
2
                                                    let v128 = &constructor_value_to_skeleton_inst_simplification(ctx, v127);
12880
                                                    // Rule at src/opts/cprop.isle line 20.
12881
2
                                                    returns.extend(Some(v128.clone()));
12882
2
                                                    if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
12883
0
                                                }
12884
0
                                            }
12885
500
                                        }
12886
                                    }
12887
0
                                }
12888
0
                            }
12889
                        }
12890
                    }
12891
                    &Opcode::Urem => {
12892
708
                        let v5 = C::unpack_value_array_2(ctx, v4);
12893
708
                        let mut v15 = C::inst_data_value_etor_returns::default();
12894
708
                        C::inst_data_value_etor(ctx, v5.1, &mut v15);
12895
708
                        let mut v15 = v15.into_context_iter();
12896
1.40k
                        while let Some(
v16694
) = v15.next(ctx) {
12897
                            if let &InstructionData::UnaryImm {
12898
553
                                opcode: ref v19,
12899
553
                                imm: v20,
12900
694
                            } = &v16.1 {
12901
553
                                if let &Opcode::Iconst = v19 {
12902
553
                                    match v16.0 {
12903
                                        I32 => {
12904
332
                                            let v21 = C::u64_from_imm64(ctx, v20);
12905
332
                                            let v68 = C::u64_matches_non_zero(ctx, v21);
12906
332
                                            if let Some(v69) = v68 {
12907
332
                                                if v69 == true {
12908
332
                                                    let v70 = C::u64_from_u32(ctx, v21);
12909
332
                                                    if let Some(v71) = v70 {
12910
332
                                                        let v72 = C::u32_is_power_of_two(ctx, v71);
12911
332
                                                        if v72 == false {
12912
332
                                                            let v110 = constructor_apply_div_const_magic_u32(ctx, &Opcode::Urem, v5.0, v71);
12913
332
                                                            let v111 = &constructor_value_to_skeleton_inst_simplification(ctx, v110);
12914
                                                            // Rule at src/opts/arithmetic.isle line 152.
12915
332
                                                            returns.extend(Some(v111.clone()));
12916
332
                                                            if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
12917
0
                                                        }
12918
0
                                                    }
12919
0
                                                }
12920
0
                                            }
12921
                                        }
12922
                                        I64 => {
12923
221
                                            let v21 = C::u64_from_imm64(ctx, v20);
12924
221
                                            let v68 = C::u64_matches_non_zero(ctx, v21);
12925
221
                                            if let Some(v69) = v68 {
12926
221
                                                if v69 == true {
12927
221
                                                    let v76 = C::u64_is_power_of_two(ctx, v21);
12928
221
                                                    if v76 == false {
12929
221
                                                        let v112 = constructor_apply_div_const_magic_u64(ctx, &Opcode::Urem, v5.0, v21);
12930
221
                                                        let v113 = &constructor_value_to_skeleton_inst_simplification(ctx, v112);
12931
                                                        // Rule at src/opts/arithmetic.isle line 155.
12932
221
                                                        returns.extend(Some(v113.clone()));
12933
221
                                                        if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
12934
0
                                                    }
12935
0
                                                }
12936
0
                                            }
12937
                                        }
12938
0
                                        _ => {}
12939
                                    }
12940
553
                                    let v21 = C::u64_from_imm64(ctx, v20);
12941
553
                                    if v21 == 0x1_u64 {
12942
0
                                        let v92 = constructor_iconst_u(ctx, v16.0, 0x0_u64);
12943
0
                                        let v93 = &constructor_value_to_skeleton_inst_simplification(ctx, v92);
12944
                                        // Rule at src/opts/arithmetic.isle line 125.
12945
0
                                        returns.extend(Some(v93.clone()));
12946
0
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
12947
553
                                    }
12948
553
                                    let v22 = C::u64_matches_power_of_two(ctx, v21);
12949
553
                                    if let Some(v23) = v22 {
12950
553
                                        if v23 == true {
12951
0
                                            let v30 = C::u64_gt(ctx, v21, 0x1_u64);
12952
0
                                            if v30 == true {
12953
0
                                                let v24 = C::u64_ilog2(ctx, v21);
12954
0
                                                let v96 = C::u64_shl(ctx, 0x1_u64, v24);
12955
0
                                                let v97 = C::u64_sub(ctx, v96, 0x1_u64);
12956
0
                                                let v98 = constructor_iconst_u(ctx, v16.0, v97);
12957
0
                                                let v99 = constructor_band(ctx, v16.0, v5.0, v98);
12958
0
                                                let v100 = &constructor_value_to_skeleton_inst_simplification(ctx, v99);
12959
                                                // Rule at src/opts/arithmetic.isle line 130.
12960
0
                                                returns.extend(Some(v100.clone()));
12961
0
                                                if returns.len() >= MAX_ISLE_RETURNS { return; }
12962
0
                                            }
12963
553
                                        }
12964
0
                                    }
12965
0
                                }
12966
141
                            }
12967
                        }
12968
                    }
12969
                    &Opcode::Srem => {
12970
0
                        let v5 = C::unpack_value_array_2(ctx, v4);
12971
0
                        let mut v8 = C::inst_data_value_tupled_etor_returns::default();
12972
0
                        C::inst_data_value_tupled_etor(ctx, v5.1, &mut v8);
12973
0
                        let mut v8 = v8.into_context_iter();
12974
0
                        while let Some(v9) = v8.next(ctx) {
12975
0
                            let v10 = C::iconst_sextend_etor(ctx, v9);
12976
0
                            if let Some(v11) = v10 {
12977
0
                                match v11.0 {
12978
                                    I32 => {
12979
0
                                        let v79 = C::i64_matches_non_zero(ctx, v11.1);
12980
0
                                        if let Some(v80) = v79 {
12981
0
                                            if v80 == true {
12982
0
                                                let v81 = C::i64_from_i32(ctx, v11.1);
12983
0
                                                if let Some(v82) = v81 {
12984
0
                                                    let v83 = C::i32_into_i64(ctx, v82);
12985
0
                                                    let v84 = constructor_i64_is_any_sign_power_of_two(ctx, v83);
12986
0
                                                    if v84 == false {
12987
0
                                                        let v115 = constructor_apply_div_const_magic_s32(ctx, &Opcode::Srem, v5.0, v82);
12988
0
                                                        let v116 = &constructor_value_to_skeleton_inst_simplification(ctx, v115);
12989
                                                        // Rule at src/opts/arithmetic.isle line 160.
12990
0
                                                        returns.extend(Some(v116.clone()));
12991
0
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
12992
0
                                                    }
12993
0
                                                }
12994
0
                                            }
12995
0
                                        }
12996
                                    }
12997
                                    I64 => {
12998
0
                                        let v79 = C::i64_matches_non_zero(ctx, v11.1);
12999
0
                                        if let Some(v80) = v79 {
13000
0
                                            if v80 == true {
13001
0
                                                let v88 = constructor_i64_is_any_sign_power_of_two(ctx, v11.1);
13002
0
                                                if v88 == false {
13003
0
                                                    let v117 = constructor_apply_div_const_magic_s64(ctx, &Opcode::Srem, v5.0, v11.1);
13004
0
                                                    let v118 = &constructor_value_to_skeleton_inst_simplification(ctx, v117);
13005
                                                    // Rule at src/opts/arithmetic.isle line 163.
13006
0
                                                    returns.extend(Some(v118.clone()));
13007
0
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
13008
0
                                                }
13009
0
                                            }
13010
0
                                        }
13011
                                    }
13012
0
                                    _ => {}
13013
                                }
13014
0
                                if v11.1 == -1_i64 {
13015
0
                                    let v94 = constructor_iconst_u(ctx, v11.0, 0x0_u64);
13016
0
                                    let v95 = &constructor_value_to_skeleton_inst_simplification(ctx, v94);
13017
                                    // Rule at src/opts/arithmetic.isle line 127.
13018
0
                                    returns.extend(Some(v95.clone()));
13019
0
                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
13020
0
                                }
13021
0
                                let v50 = C::i64_ne(ctx, v11.1, -1_i64);
13022
0
                                if v50 == true {
13023
0
                                    let v88 = constructor_i64_is_any_sign_power_of_two(ctx, v11.1);
13024
0
                                    if v88 == true {
13025
0
                                        let v102 = C::i64_ne(ctx, v11.1, 1_i64);
13026
0
                                        if v102 == true {
13027
0
                                            let v51 = C::i64_trailing_zeros(ctx, v11.1);
13028
0
                                            let v52 = C::u32_sub(ctx, v51, 0x1_u32);
13029
0
                                            let v53 = C::u32_into_u64(ctx, v52);
13030
0
                                            let v54 = constructor_iconst_u(ctx, v11.0, v53);
13031
0
                                            let v55 = constructor_sshr(ctx, v11.0, v5.0, v54);
13032
0
                                            let v56 = C::ty_bits(ctx, v11.0);
13033
0
                                            let v57 = C::u8_into_u32(ctx, v56);
13034
0
                                            let v58 = C::u32_sub(ctx, v57, v51);
13035
0
                                            let v59 = C::u32_into_u64(ctx, v58);
13036
0
                                            let v60 = constructor_iconst_u(ctx, v11.0, v59);
13037
0
                                            let v61 = constructor_ushr(ctx, v11.0, v55, v60);
13038
0
                                            let v62 = constructor_iadd(ctx, v11.0, v5.0, v61);
13039
0
                                            let v103 = C::i64_shl(ctx, 1_i64, v51);
13040
0
                                            let v104 = C::i64_wrapping_neg(ctx, v103);
13041
0
                                            let v105 = constructor_iconst_s(ctx, v11.0, v104);
13042
0
                                            let v106 = constructor_band(ctx, v11.0, v62, v105);
13043
0
                                            let v107 = constructor_isub(ctx, v11.0, v5.0, v106);
13044
0
                                            let v108 = &constructor_value_to_skeleton_inst_simplification(ctx, v107);
13045
                                            // Rule at src/opts/arithmetic.isle line 137.
13046
0
                                            returns.extend(Some(v108.clone()));
13047
0
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
13048
0
                                        }
13049
0
                                    }
13050
0
                                }
13051
0
                            }
13052
                        }
13053
0
                        let mut v15 = C::inst_data_value_etor_returns::default();
13054
0
                        C::inst_data_value_etor(ctx, v5.1, &mut v15);
13055
0
                        let mut v15 = v15.into_context_iter();
13056
0
                        while let Some(v16) = v15.next(ctx) {
13057
                            if let &InstructionData::UnaryImm {
13058
0
                                opcode: ref v19,
13059
0
                                imm: v20,
13060
0
                            } = &v16.1 {
13061
0
                                if let &Opcode::Iconst = v19 {
13062
0
                                    let v21 = C::u64_from_imm64(ctx, v20);
13063
0
                                    if v21 == 0x1_u64 {
13064
0
                                        let v92 = constructor_iconst_u(ctx, v16.0, 0x0_u64);
13065
0
                                        let v93 = &constructor_value_to_skeleton_inst_simplification(ctx, v92);
13066
                                        // Rule at src/opts/arithmetic.isle line 126.
13067
0
                                        returns.extend(Some(v93.clone()));
13068
0
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
13069
0
                                    }
13070
0
                                }
13071
0
                            }
13072
                        }
13073
                    }
13074
0
                    _ => {}
13075
                }
13076
            }
13077
            &InstructionData::CondTrap {
13078
30.1k
                opcode: ref v135,
13079
30.1k
                arg: v136,
13080
30.1k
                code: ref v137,
13081
            } => {
13082
30.1k
                match v135 {
13083
                    &Opcode::Trapz => {
13084
29.9k
                        let mut v138 = C::inst_data_value_etor_returns::default();
13085
29.9k
                        C::inst_data_value_etor(ctx, v136, &mut v138);
13086
29.9k
                        let mut v138 = v138.into_context_iter();
13087
59.9k
                        while let Some(
v13929.9k
) = v138.next(ctx) {
13088
                            if let &InstructionData::UnaryImm {
13089
0
                                opcode: ref v142,
13090
0
                                imm: v143,
13091
29.9k
                            } = &v139.1 {
13092
0
                                if let &Opcode::Iconst = v142 {
13093
0
                                    let v144 = C::u64_from_imm64(ctx, v143);
13094
0
                                    let v145 = C::u64_matches_non_zero(ctx, v144);
13095
0
                                    if let Some(v146) = v145 {
13096
0
                                        if v146 == true {
13097
0
                                            let v147 = &constructor_remove_inst(ctx);
13098
                                            // Rule at src/opts/skeleton.isle line 6.
13099
0
                                            returns.extend(Some(v147.clone()));
13100
0
                                            if returns.len() >= MAX_ISLE_RETURNS { return; }
13101
0
                                        }
13102
0
                                    }
13103
0
                                }
13104
29.9k
                            }
13105
                        }
13106
                    }
13107
                    &Opcode::Trapnz => {
13108
131
                        let mut v138 = C::inst_data_value_etor_returns::default();
13109
131
                        C::inst_data_value_etor(ctx, v136, &mut v138);
13110
131
                        let mut v138 = v138.into_context_iter();
13111
262
                        while let Some(
v139131
) = v138.next(ctx) {
13112
                            if let &InstructionData::UnaryImm {
13113
0
                                opcode: ref v142,
13114
0
                                imm: v143,
13115
131
                            } = &v139.1 {
13116
0
                                if let &Opcode::Iconst = v142 {
13117
0
                                    let v144 = C::u64_from_imm64(ctx, v143);
13118
0
                                    if v144 == 0x0_u64 {
13119
0
                                        let v147 = &constructor_remove_inst(ctx);
13120
                                        // Rule at src/opts/skeleton.isle line 8.
13121
0
                                        returns.extend(Some(v147.clone()));
13122
0
                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
13123
0
                                    }
13124
0
                                }
13125
131
                            }
13126
                        }
13127
                    }
13128
0
                    _ => {}
13129
                }
13130
            }
13131
            &InstructionData::IntAddTrap {
13132
0
                opcode: ref v148,
13133
0
                args: ref v149,
13134
0
                code: ref v150,
13135
            } => {
13136
0
                if let &Opcode::UaddOverflowTrap = v148 {
13137
0
                    let v151 = C::unpack_value_array_2(ctx, v149);
13138
0
                    let mut v154 = C::inst_data_value_etor_returns::default();
13139
0
                    C::inst_data_value_etor(ctx, v151.0, &mut v154);
13140
0
                    let mut v154 = v154.into_context_iter();
13141
0
                    while let Some(v155) = v154.next(ctx) {
13142
0
                        match &v155.1 {
13143
                            &InstructionData::Unary {
13144
0
                                opcode: ref v172,
13145
0
                                arg: v173,
13146
                            } => {
13147
0
                                if let &Opcode::Uextend = v172 {
13148
0
                                    let mut v161 = C::inst_data_value_etor_returns::default();
13149
0
                                    C::inst_data_value_etor(ctx, v151.1, &mut v161);
13150
0
                                    let mut v161 = v161.into_context_iter();
13151
0
                                    while let Some(v162) = v161.next(ctx) {
13152
                                        if let &InstructionData::Unary {
13153
0
                                            opcode: ref v174,
13154
0
                                            arg: v175,
13155
0
                                        } = &v162.1 {
13156
0
                                            if let &Opcode::Uextend = v174 {
13157
0
                                                if v155.0 == v162.0 {
13158
0
                                                    let v176 = constructor_iadd(ctx, v155.0, v151.0, v151.1);
13159
0
                                                    let v177 = &constructor_value_to_skeleton_inst_simplification(ctx, v176);
13160
                                                    // Rule at src/opts/skeleton.isle line 17.
13161
0
                                                    returns.extend(Some(v177.clone()));
13162
0
                                                    if returns.len() >= MAX_ISLE_RETURNS { return; }
13163
0
                                                }
13164
0
                                            }
13165
0
                                        }
13166
                                    }
13167
0
                                }
13168
                            }
13169
                            &InstructionData::UnaryImm {
13170
0
                                opcode: ref v158,
13171
0
                                imm: v159,
13172
                            } => {
13173
0
                                if let &Opcode::Iconst = v158 {
13174
0
                                    let mut v161 = C::inst_data_value_etor_returns::default();
13175
0
                                    C::inst_data_value_etor(ctx, v151.1, &mut v161);
13176
0
                                    let mut v161 = v161.into_context_iter();
13177
0
                                    while let Some(v162) = v161.next(ctx) {
13178
                                        if let &InstructionData::UnaryImm {
13179
0
                                            opcode: ref v165,
13180
0
                                            imm: v166,
13181
0
                                        } = &v162.1 {
13182
0
                                            if let &Opcode::Iconst = v165 {
13183
0
                                                let v160 = C::u64_from_imm64(ctx, v159);
13184
0
                                                let v167 = C::u64_from_imm64(ctx, v166);
13185
0
                                                let v168 = C::checked_add_with_type(ctx, v155.0, v160, v167);
13186
0
                                                if let Some(v169) = v168 {
13187
0
                                                    if v155.0 == v162.0 {
13188
0
                                                        let v170 = constructor_iconst_u(ctx, v155.0, v169);
13189
0
                                                        let v171 = &constructor_value_to_skeleton_inst_simplification(ctx, v170);
13190
                                                        // Rule at src/opts/skeleton.isle line 12.
13191
0
                                                        returns.extend(Some(v171.clone()));
13192
0
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
13193
0
                                                    }
13194
0
                                                }
13195
0
                                            }
13196
0
                                        }
13197
                                    }
13198
0
                                }
13199
                            }
13200
0
                            _ => {}
13201
                        }
13202
                    }
13203
0
                }
13204
            }
13205
2.32M
            _ => {}
13206
        }
13207
0
    }
13208
2.36M
}
13209
13210
// Generated as internal constructor for term iconst_s.
13211
2.73k
pub fn constructor_iconst_s<C: Context>(
13212
2.73k
    ctx: &mut C,
13213
2.73k
    arg0: Type,
13214
2.73k
    arg1: i64,
13215
2.73k
) -> Value {
13216
2.73k
    if arg0 == I128 {
13217
0
        let v11 = constructor_iconst_s(ctx, I64, arg1);
13218
0
        let v12 = constructor_sextend(ctx, I128, v11);
13219
        // Rule at src/prelude_opt.isle line 141.
13220
0
        return v12;
13221
2.73k
    }
13222
2.73k
    let v2 = C::i64_cast_unsigned(ctx, arg1);
13223
2.73k
    let v3 = C::ty_umax(ctx, arg0);
13224
2.73k
    let v4 = C::u64_and(ctx, v2, v3);
13225
2.73k
    let v5 = C::i64_sextend_u64(ctx, arg0, v4);
13226
2.73k
    let v6 = C::i64_eq(ctx, arg1, v5);
13227
2.73k
    if v6 == true {
13228
2.73k
        let v7 = C::imm64(ctx, v4);
13229
2.73k
        let v8 = constructor_iconst(ctx, arg0, v7);
13230
        // Rule at src/prelude_opt.isle line 135.
13231
2.73k
        return v8;
13232
0
    }
13233
0
    unreachable!("no rule matched for term {} at {}; should it be partial?", "iconst_s", "src/prelude_opt.isle line 133")
13234
2.73k
}
13235
13236
// Generated as internal constructor for term iconst_u.
13237
20.4k
pub fn constructor_iconst_u<C: Context>(
13238
20.4k
    ctx: &mut C,
13239
20.4k
    arg0: Type,
13240
20.4k
    arg1: u64,
13241
20.4k
) -> Value {
13242
20.4k
    if arg0 == I128 {
13243
0
        let v8 = constructor_iconst_u(ctx, I64, arg1);
13244
0
        let v9 = constructor_uextend(ctx, I128, v8);
13245
        // Rule at src/prelude_opt.isle line 154.
13246
0
        return v9;
13247
20.4k
    }
13248
20.4k
    let v2 = C::ty_umax(ctx, arg0);
13249
20.4k
    let v3 = C::u64_lt_eq(ctx, arg1, v2);
13250
20.4k
    if v3 == true {
13251
20.4k
        let v4 = C::imm64(ctx, arg1);
13252
20.4k
        let v5 = constructor_iconst(ctx, arg0, v4);
13253
        // Rule at src/prelude_opt.isle line 151.
13254
20.4k
        return v5;
13255
0
    }
13256
0
    unreachable!("no rule matched for term {} at {}; should it be partial?", "iconst_u", "src/prelude_opt.isle line 149")
13257
20.4k
}
13258
13259
// Generated as internal constructor for term uextend_maybe.
13260
0
pub fn constructor_uextend_maybe<C: Context>(
13261
0
    ctx: &mut C,
13262
0
    arg0: Type,
13263
0
    arg1: Value,
13264
0
) -> Value {
13265
0
    let v3 = C::value_type(ctx, arg1);
13266
0
    if arg0 == v3 {
13267
        // Rule at src/prelude_opt.isle line 174.
13268
0
        return arg1;
13269
0
    }
13270
0
    let v2 = constructor_uextend(ctx, arg0, arg1);
13271
    // Rule at src/prelude_opt.isle line 173.
13272
0
    return v2;
13273
0
}
13274
13275
// Generated as internal constructor for term sextend_maybe.
13276
339
pub fn constructor_sextend_maybe<C: Context>(
13277
339
    ctx: &mut C,
13278
339
    arg0: Type,
13279
339
    arg1: Value,
13280
339
) -> Value {
13281
339
    let v3 = C::value_type(ctx, arg1);
13282
339
    if arg0 == v3 {
13283
        // Rule at src/prelude_opt.isle line 180.
13284
0
        return arg1;
13285
339
    }
13286
339
    let v2 = constructor_sextend(ctx, arg0, arg1);
13287
    // Rule at src/prelude_opt.isle line 179.
13288
339
    return v2;
13289
339
}
13290
13291
// Generated as internal constructor for term eq.
13292
3.13k
pub fn constructor_eq<C: Context>(
13293
3.13k
    ctx: &mut C,
13294
3.13k
    arg0: Type,
13295
3.13k
    arg1: Value,
13296
3.13k
    arg2: Value,
13297
3.13k
) -> Value {
13298
3.13k
    let v4 = constructor_icmp(ctx, arg0, &IntCC::Equal, arg1, arg2);
13299
    // Rule at src/prelude_opt.isle line 38.
13300
3.13k
    return v4;
13301
3.13k
}
13302
13303
// Generated as internal constructor for term ne.
13304
1.18k
pub fn constructor_ne<C: Context>(
13305
1.18k
    ctx: &mut C,
13306
1.18k
    arg0: Type,
13307
1.18k
    arg1: Value,
13308
1.18k
    arg2: Value,
13309
1.18k
) -> Value {
13310
1.18k
    let v4 = constructor_icmp(ctx, arg0, &IntCC::NotEqual, arg1, arg2);
13311
    // Rule at src/prelude_opt.isle line 39.
13312
1.18k
    return v4;
13313
1.18k
}
13314
13315
// Generated as internal constructor for term ult.
13316
1.18k
pub fn constructor_ult<C: Context>(
13317
1.18k
    ctx: &mut C,
13318
1.18k
    arg0: Type,
13319
1.18k
    arg1: Value,
13320
1.18k
    arg2: Value,
13321
1.18k
) -> Value {
13322
1.18k
    let v4 = constructor_icmp(ctx, arg0, &IntCC::UnsignedLessThan, arg1, arg2);
13323
    // Rule at src/prelude_opt.isle line 40.
13324
1.18k
    return v4;
13325
1.18k
}
13326
13327
// Generated as internal constructor for term ule.
13328
87
pub fn constructor_ule<C: Context>(
13329
87
    ctx: &mut C,
13330
87
    arg0: Type,
13331
87
    arg1: Value,
13332
87
    arg2: Value,
13333
87
) -> Value {
13334
87
    let v4 = constructor_icmp(ctx, arg0, &IntCC::UnsignedLessThanOrEqual, arg1, arg2);
13335
    // Rule at src/prelude_opt.isle line 41.
13336
87
    return v4;
13337
87
}
13338
13339
// Generated as internal constructor for term ugt.
13340
988
pub fn constructor_ugt<C: Context>(
13341
988
    ctx: &mut C,
13342
988
    arg0: Type,
13343
988
    arg1: Value,
13344
988
    arg2: Value,
13345
988
) -> Value {
13346
988
    let v4 = constructor_icmp(ctx, arg0, &IntCC::UnsignedGreaterThan, arg1, arg2);
13347
    // Rule at src/prelude_opt.isle line 42.
13348
988
    return v4;
13349
988
}
13350
13351
// Generated as internal constructor for term uge.
13352
72
pub fn constructor_uge<C: Context>(
13353
72
    ctx: &mut C,
13354
72
    arg0: Type,
13355
72
    arg1: Value,
13356
72
    arg2: Value,
13357
72
) -> Value {
13358
72
    let v4 = constructor_icmp(ctx, arg0, &IntCC::UnsignedGreaterThanOrEqual, arg1, arg2);
13359
    // Rule at src/prelude_opt.isle line 43.
13360
72
    return v4;
13361
72
}
13362
13363
// Generated as internal constructor for term slt.
13364
616
pub fn constructor_slt<C: Context>(
13365
616
    ctx: &mut C,
13366
616
    arg0: Type,
13367
616
    arg1: Value,
13368
616
    arg2: Value,
13369
616
) -> Value {
13370
616
    let v4 = constructor_icmp(ctx, arg0, &IntCC::SignedLessThan, arg1, arg2);
13371
    // Rule at src/prelude_opt.isle line 44.
13372
616
    return v4;
13373
616
}
13374
13375
// Generated as internal constructor for term sle.
13376
195
pub fn constructor_sle<C: Context>(
13377
195
    ctx: &mut C,
13378
195
    arg0: Type,
13379
195
    arg1: Value,
13380
195
    arg2: Value,
13381
195
) -> Value {
13382
195
    let v4 = constructor_icmp(ctx, arg0, &IntCC::SignedLessThanOrEqual, arg1, arg2);
13383
    // Rule at src/prelude_opt.isle line 45.
13384
195
    return v4;
13385
195
}
13386
13387
// Generated as internal constructor for term sgt.
13388
290
pub fn constructor_sgt<C: Context>(
13389
290
    ctx: &mut C,
13390
290
    arg0: Type,
13391
290
    arg1: Value,
13392
290
    arg2: Value,
13393
290
) -> Value {
13394
290
    let v4 = constructor_icmp(ctx, arg0, &IntCC::SignedGreaterThan, arg1, arg2);
13395
    // Rule at src/prelude_opt.isle line 46.
13396
290
    return v4;
13397
290
}
13398
13399
// Generated as internal constructor for term sge.
13400
340
pub fn constructor_sge<C: Context>(
13401
340
    ctx: &mut C,
13402
340
    arg0: Type,
13403
340
    arg1: Value,
13404
340
    arg2: Value,
13405
340
) -> Value {
13406
340
    let v4 = constructor_icmp(ctx, arg0, &IntCC::SignedGreaterThanOrEqual, arg1, arg2);
13407
    // Rule at src/prelude_opt.isle line 47.
13408
340
    return v4;
13409
340
}
13410
13411
// Generated as internal constructor for term i64_is_negative_power_of_two.
13412
1.00k
pub fn constructor_i64_is_negative_power_of_two<C: Context>(
13413
1.00k
    ctx: &mut C,
13414
1.00k
    arg0: i64,
13415
1.00k
) -> bool {
13416
1.00k
    let v1 = C::i64_wrapping_neg(ctx, arg0);
13417
1.00k
    let v2 = C::i64_cast_unsigned(ctx, v1);
13418
1.00k
    let v3 = C::u64_is_power_of_two(ctx, v2);
13419
    // Rule at src/prelude_opt.isle line 217.
13420
1.00k
    return v3;
13421
1.00k
}
13422
13423
// Generated as internal constructor for term i64_is_any_sign_power_of_two.
13424
501
pub fn constructor_i64_is_any_sign_power_of_two<C: Context>(
13425
501
    ctx: &mut C,
13426
501
    arg0: i64,
13427
501
) -> bool {
13428
501
    let v1 = C::i64_cast_unsigned(ctx, arg0);
13429
501
    let v2 = C::u64_is_power_of_two(ctx, v1);
13430
501
    if v2 == true {
13431
0
        let v3 = true;
13432
        // Rule at src/prelude_opt.isle line 221.
13433
0
        return v3;
13434
501
    }
13435
501
    let v4 = constructor_i64_is_negative_power_of_two(ctx, arg0);
13436
501
    if v4 == true {
13437
0
        let v3 = true;
13438
        // Rule at src/prelude_opt.isle line 224.
13439
0
        return v3;
13440
501
    }
13441
501
    let v5 = false;
13442
    // Rule at src/prelude_opt.isle line 227.
13443
501
    return v5;
13444
501
}
13445
13446
// Generated as internal constructor for term apply_div_const_magic_u32.
13447
2.49k
pub fn constructor_apply_div_const_magic_u32<C: Context>(
13448
2.49k
    ctx: &mut C,
13449
2.49k
    arg0: &Opcode,
13450
2.49k
    arg1: Value,
13451
2.49k
    arg2: u32,
13452
2.49k
) -> Value {
13453
2.49k
    let v3 = &C::div_const_magic_u32(ctx, arg2);
13454
2.49k
    let v4 = constructor_apply_div_const_magic_u32_inner(ctx, arg0, arg1, arg2, v3);
13455
    // Rule at src/prelude_opt.isle line 256.
13456
2.49k
    return v4;
13457
2.49k
}
13458
13459
// Generated as internal constructor for term apply_div_const_magic_u32_inner.
13460
2.49k
pub fn constructor_apply_div_const_magic_u32_inner<C: Context>(
13461
2.49k
    ctx: &mut C,
13462
2.49k
    arg0: &Opcode,
13463
2.49k
    arg1: Value,
13464
2.49k
    arg2: u32,
13465
2.49k
    arg3: &DivConstMagicU32,
13466
2.49k
) -> Value {
13467
    if let &DivConstMagicU32::U32 {
13468
2.49k
        mul_by: v4,
13469
2.49k
        do_add: v5,
13470
2.49k
        shift_by: v6,
13471
2.49k
    } = arg3 {
13472
2.49k
        let v8 = C::u32_into_u64(ctx, v4);
13473
2.49k
        let v9 = constructor_iconst_u(ctx, I32, v8);
13474
2.49k
        let v10 = constructor_umulhi(ctx, I32, arg1, v9);
13475
2.49k
        let v11 = constructor_apply_div_const_magic_u32_maybe_add(ctx, arg0, arg1, arg2, arg3, v10);
13476
        // Rule at src/prelude_opt.isle line 261.
13477
2.49k
        return v11;
13478
    }
13479
    unreachable!("no rule matched for term {} at {}; should it be partial?", "apply_div_const_magic_u32_inner", "src/prelude_opt.isle line 260")
13480
2.49k
}
13481
13482
// Generated as internal constructor for term apply_div_const_magic_u32_maybe_add.
13483
2.49k
pub fn constructor_apply_div_const_magic_u32_maybe_add<C: Context>(
13484
2.49k
    ctx: &mut C,
13485
2.49k
    arg0: &Opcode,
13486
2.49k
    arg1: Value,
13487
2.49k
    arg2: u32,
13488
2.49k
    arg3: &DivConstMagicU32,
13489
2.49k
    arg4: Value,
13490
2.49k
) -> Value {
13491
    if let &DivConstMagicU32::U32 {
13492
2.49k
        mul_by: v4,
13493
2.49k
        do_add: v5,
13494
2.49k
        shift_by: v6,
13495
2.49k
    } = arg3 {
13496
2.49k
        match v5 {
13497
            false => {
13498
2.26k
                let v15 = C::u32_into_u64(ctx, v6);
13499
2.26k
                let v16 = constructor_iconst_u(ctx, I32, v15);
13500
2.26k
                let v17 = constructor_ushr(ctx, I32, arg4, v16);
13501
2.26k
                let v18 = constructor_apply_div_const_magic_u32_finish(ctx, arg0, arg1, arg2, v17);
13502
                // Rule at src/prelude_opt.isle line 286.
13503
2.26k
                return v18;
13504
            }
13505
            true => {
13506
231
                let v9 = constructor_isub(ctx, I32, arg1, arg4);
13507
231
                let v11 = constructor_iconst_u(ctx, I32, 0x1_u64);
13508
231
                let v12 = constructor_ushr(ctx, I32, v9, v11);
13509
231
                let v13 = constructor_iadd(ctx, I32, arg4, v12);
13510
231
                let v14 = constructor_apply_div_const_magic_u32_maybe_shift(ctx, arg0, arg1, arg2, arg3, v13);
13511
                // Rule at src/prelude_opt.isle line 277.
13512
231
                return v14;
13513
            }
13514
            _ => {}
13515
        }
13516
    }
13517
    unreachable!("no rule matched for term {} at {}; should it be partial?", "apply_div_const_magic_u32_maybe_add", "src/prelude_opt.isle line 276")
13518
2.49k
}
13519
13520
// Generated as internal constructor for term apply_div_const_magic_u32_maybe_shift.
13521
231
pub fn constructor_apply_div_const_magic_u32_maybe_shift<C: Context>(
13522
231
    ctx: &mut C,
13523
231
    arg0: &Opcode,
13524
231
    arg1: Value,
13525
231
    arg2: u32,
13526
231
    arg3: &DivConstMagicU32,
13527
231
    arg4: Value,
13528
231
) -> Value {
13529
    if let &DivConstMagicU32::U32 {
13530
231
        mul_by: v4,
13531
231
        do_add: v5,
13532
231
        shift_by: v6,
13533
231
    } = arg3 {
13534
231
        if v6 == 0x0_u32 {
13535
0
            let v8 = constructor_apply_div_const_magic_u32_finish(ctx, arg0, arg1, arg2, arg4);
13536
            // Rule at src/prelude_opt.isle line 300.
13537
0
            return v8;
13538
231
        }
13539
231
        let v9 = C::u32_matches_non_zero(ctx, v6);
13540
231
        if let Some(v10) = v9 {
13541
231
            if v10 == true {
13542
231
                let v13 = C::u32_sub(ctx, v6, 0x1_u32);
13543
231
                let v14 = C::u32_into_u64(ctx, v13);
13544
231
                let v15 = constructor_iconst_u(ctx, I32, v14);
13545
231
                let v16 = constructor_ushr(ctx, I32, arg4, v15);
13546
231
                let v17 = constructor_apply_div_const_magic_u32_finish(ctx, arg0, arg1, arg2, v16);
13547
                // Rule at src/prelude_opt.isle line 306.
13548
231
                return v17;
13549
0
            }
13550
0
        }
13551
    }
13552
0
    unreachable!("no rule matched for term {} at {}; should it be partial?", "apply_div_const_magic_u32_maybe_shift", "src/prelude_opt.isle line 299")
13553
231
}
13554
13555
// Generated as internal constructor for term apply_div_const_magic_u32_finish.
13556
2.49k
pub fn constructor_apply_div_const_magic_u32_finish<C: Context>(
13557
2.49k
    ctx: &mut C,
13558
2.49k
    arg0: &Opcode,
13559
2.49k
    arg1: Value,
13560
2.49k
    arg2: u32,
13561
2.49k
    arg3: Value,
13562
2.49k
) -> Value {
13563
2.49k
    match arg0 {
13564
        &Opcode::Udiv => {
13565
            // Rule at src/prelude_opt.isle line 326.
13566
2.16k
            return arg3;
13567
        }
13568
        &Opcode::Urem => {
13569
332
            let v5 = C::u32_into_u64(ctx, arg2);
13570
332
            let v6 = constructor_iconst_u(ctx, I32, v5);
13571
332
            let v7 = constructor_imul(ctx, I32, arg3, v6);
13572
332
            let v8 = constructor_isub(ctx, I32, arg1, v7);
13573
            // Rule at src/prelude_opt.isle line 327.
13574
332
            return v8;
13575
        }
13576
0
        _ => {}
13577
    }
13578
0
    unreachable!("no rule matched for term {} at {}; should it be partial?", "apply_div_const_magic_u32_finish", "src/prelude_opt.isle line 325")
13579
2.49k
}
13580
13581
// Generated as internal constructor for term apply_div_const_magic_u64.
13582
756
pub fn constructor_apply_div_const_magic_u64<C: Context>(
13583
756
    ctx: &mut C,
13584
756
    arg0: &Opcode,
13585
756
    arg1: Value,
13586
756
    arg2: u64,
13587
756
) -> Value {
13588
756
    let v3 = &C::div_const_magic_u64(ctx, arg2);
13589
756
    let v4 = constructor_apply_div_const_magic_u64_inner(ctx, arg0, arg1, arg2, v3);
13590
    // Rule at src/prelude_opt.isle line 333.
13591
756
    return v4;
13592
756
}
13593
13594
// Generated as internal constructor for term apply_div_const_magic_u64_inner.
13595
756
pub fn constructor_apply_div_const_magic_u64_inner<C: Context>(
13596
756
    ctx: &mut C,
13597
756
    arg0: &Opcode,
13598
756
    arg1: Value,
13599
756
    arg2: u64,
13600
756
    arg3: &DivConstMagicU64,
13601
756
) -> Value {
13602
    if let &DivConstMagicU64::U64 {
13603
756
        mul_by: v4,
13604
756
        do_add: v5,
13605
756
        shift_by: v6,
13606
756
    } = arg3 {
13607
756
        let v8 = constructor_iconst_u(ctx, I64, v4);
13608
756
        let v9 = constructor_umulhi(ctx, I64, arg1, v8);
13609
756
        let v10 = constructor_apply_div_const_magic_u64_maybe_add(ctx, arg0, arg1, arg2, arg3, v9);
13610
        // Rule at src/prelude_opt.isle line 338.
13611
756
        return v10;
13612
    }
13613
    unreachable!("no rule matched for term {} at {}; should it be partial?", "apply_div_const_magic_u64_inner", "src/prelude_opt.isle line 337")
13614
756
}
13615
13616
// Generated as internal constructor for term apply_div_const_magic_u64_maybe_add.
13617
756
pub fn constructor_apply_div_const_magic_u64_maybe_add<C: Context>(
13618
756
    ctx: &mut C,
13619
756
    arg0: &Opcode,
13620
756
    arg1: Value,
13621
756
    arg2: u64,
13622
756
    arg3: &DivConstMagicU64,
13623
756
    arg4: Value,
13624
756
) -> Value {
13625
    if let &DivConstMagicU64::U64 {
13626
756
        mul_by: v4,
13627
756
        do_add: v5,
13628
756
        shift_by: v6,
13629
756
    } = arg3 {
13630
756
        match v5 {
13631
            false => {
13632
357
                let v15 = C::u32_into_u64(ctx, v6);
13633
357
                let v16 = constructor_iconst_u(ctx, I64, v15);
13634
357
                let v17 = constructor_ushr(ctx, I64, arg4, v16);
13635
357
                let v18 = constructor_apply_div_const_magic_u64_finish(ctx, arg0, arg1, arg2, v17);
13636
                // Rule at src/prelude_opt.isle line 363.
13637
357
                return v18;
13638
            }
13639
            true => {
13640
399
                let v9 = constructor_isub(ctx, I64, arg1, arg4);
13641
399
                let v11 = constructor_iconst_u(ctx, I64, 0x1_u64);
13642
399
                let v12 = constructor_ushr(ctx, I64, v9, v11);
13643
399
                let v13 = constructor_iadd(ctx, I64, arg4, v12);
13644
399
                let v14 = constructor_apply_div_const_magic_u64_maybe_shift(ctx, arg0, arg1, arg2, arg3, v13);
13645
                // Rule at src/prelude_opt.isle line 354.
13646
399
                return v14;
13647
            }
13648
            _ => {}
13649
        }
13650
    }
13651
    unreachable!("no rule matched for term {} at {}; should it be partial?", "apply_div_const_magic_u64_maybe_add", "src/prelude_opt.isle line 353")
13652
756
}
13653
13654
// Generated as internal constructor for term apply_div_const_magic_u64_maybe_shift.
13655
399
pub fn constructor_apply_div_const_magic_u64_maybe_shift<C: Context>(
13656
399
    ctx: &mut C,
13657
399
    arg0: &Opcode,
13658
399
    arg1: Value,
13659
399
    arg2: u64,
13660
399
    arg3: &DivConstMagicU64,
13661
399
    arg4: Value,
13662
399
) -> Value {
13663
    if let &DivConstMagicU64::U64 {
13664
399
        mul_by: v4,
13665
399
        do_add: v5,
13666
399
        shift_by: v6,
13667
399
    } = arg3 {
13668
399
        if v6 == 0x0_u32 {
13669
0
            let v8 = constructor_apply_div_const_magic_u64_finish(ctx, arg0, arg1, arg2, arg4);
13670
            // Rule at src/prelude_opt.isle line 377.
13671
0
            return v8;
13672
399
        }
13673
399
        let v9 = C::u32_matches_non_zero(ctx, v6);
13674
399
        if let Some(v10) = v9 {
13675
399
            if v10 == true {
13676
399
                let v12 = C::u32_into_u64(ctx, v6);
13677
399
                let v14 = C::u64_sub(ctx, v12, 0x1_u64);
13678
399
                let v15 = constructor_iconst_u(ctx, I64, v14);
13679
399
                let v16 = constructor_ushr(ctx, I64, arg4, v15);
13680
399
                let v17 = constructor_apply_div_const_magic_u64_finish(ctx, arg0, arg1, arg2, v16);
13681
                // Rule at src/prelude_opt.isle line 383.
13682
399
                return v17;
13683
0
            }
13684
0
        }
13685
    }
13686
0
    unreachable!("no rule matched for term {} at {}; should it be partial?", "apply_div_const_magic_u64_maybe_shift", "src/prelude_opt.isle line 376")
13687
399
}
13688
13689
// Generated as internal constructor for term apply_div_const_magic_u64_finish.
13690
756
pub fn constructor_apply_div_const_magic_u64_finish<C: Context>(
13691
756
    ctx: &mut C,
13692
756
    arg0: &Opcode,
13693
756
    arg1: Value,
13694
756
    arg2: u64,
13695
756
    arg3: Value,
13696
756
) -> Value {
13697
756
    match arg0 {
13698
        &Opcode::Udiv => {
13699
            // Rule at src/prelude_opt.isle line 403.
13700
535
            return arg3;
13701
        }
13702
        &Opcode::Urem => {
13703
221
            let v5 = constructor_iconst_u(ctx, I64, arg2);
13704
221
            let v6 = constructor_imul(ctx, I64, arg3, v5);
13705
221
            let v7 = constructor_isub(ctx, I64, arg1, v6);
13706
            // Rule at src/prelude_opt.isle line 404.
13707
221
            return v7;
13708
        }
13709
0
        _ => {}
13710
    }
13711
0
    unreachable!("no rule matched for term {} at {}; should it be partial?", "apply_div_const_magic_u64_finish", "src/prelude_opt.isle line 402")
13712
756
}
13713
13714
// Generated as internal constructor for term apply_div_const_magic_s32.
13715
501
pub fn constructor_apply_div_const_magic_s32<C: Context>(
13716
501
    ctx: &mut C,
13717
501
    arg0: &Opcode,
13718
501
    arg1: Value,
13719
501
    arg2: i32,
13720
501
) -> Value {
13721
501
    let v3 = &C::div_const_magic_s32(ctx, arg2);
13722
501
    let v4 = constructor_apply_div_const_magic_s32_inner(ctx, arg0, arg1, arg2, v3);
13723
    // Rule at src/prelude_opt.isle line 411.
13724
501
    return v4;
13725
501
}
13726
13727
// Generated as internal constructor for term apply_div_const_magic_s32_inner.
13728
501
pub fn constructor_apply_div_const_magic_s32_inner<C: Context>(
13729
501
    ctx: &mut C,
13730
501
    arg0: &Opcode,
13731
501
    arg1: Value,
13732
501
    arg2: i32,
13733
501
    arg3: &DivConstMagicS32,
13734
501
) -> Value {
13735
    if let &DivConstMagicS32::S32 {
13736
501
        mul_by: v4,
13737
501
        shift_by: v5,
13738
501
    } = arg3 {
13739
501
        let v7 = C::i32_into_i64(ctx, v4);
13740
501
        let v8 = constructor_iconst_s(ctx, I32, v7);
13741
501
        let v9 = constructor_smulhi(ctx, I32, arg1, v8);
13742
501
        let v10 = constructor_apply_div_const_magic_s32_add_sub(ctx, arg0, arg1, arg2, arg3, v9);
13743
        // Rule at src/prelude_opt.isle line 417.
13744
501
        return v10;
13745
    }
13746
    unreachable!("no rule matched for term {} at {}; should it be partial?", "apply_div_const_magic_s32_inner", "src/prelude_opt.isle line 416")
13747
501
}
13748
13749
// Generated as internal constructor for term apply_div_const_magic_s32_add_sub.
13750
501
pub fn constructor_apply_div_const_magic_s32_add_sub<C: Context>(
13751
501
    ctx: &mut C,
13752
501
    arg0: &Opcode,
13753
501
    arg1: Value,
13754
501
    arg2: i32,
13755
501
    arg3: &DivConstMagicS32,
13756
501
    arg4: Value,
13757
501
) -> Value {
13758
    if let &DivConstMagicS32::S32 {
13759
501
        mul_by: v4,
13760
501
        shift_by: v5,
13761
501
    } = arg3 {
13762
501
        let v8 = C::i32_gt(ctx, arg2, 0_i32);
13763
501
        if v8 == true {
13764
501
            let v9 = C::i32_lt(ctx, v4, 0_i32);
13765
501
            if v9 == true {
13766
32
                let v11 = constructor_iadd(ctx, I32, arg4, arg1);
13767
32
                let v12 = constructor_apply_div_const_magic_s32_shift(ctx, arg0, arg1, arg2, arg3, v11);
13768
                // Rule at src/prelude_opt.isle line 433.
13769
32
                return v12;
13770
469
            }
13771
0
        }
13772
469
        let v13 = C::i32_lt(ctx, arg2, 0_i32);
13773
469
        if v13 == true {
13774
0
            let v14 = C::i32_gt(ctx, v4, 0_i32);
13775
0
            if v14 == true {
13776
0
                let v15 = constructor_isub(ctx, I32, arg4, arg1);
13777
0
                let v16 = constructor_apply_div_const_magic_s32_shift(ctx, arg0, arg1, arg2, arg3, v15);
13778
                // Rule at src/prelude_opt.isle line 442.
13779
0
                return v16;
13780
0
            }
13781
469
        }
13782
    }
13783
469
    let v17 = constructor_apply_div_const_magic_s32_shift(ctx, arg0, arg1, arg2, arg3, arg4);
13784
    // Rule at src/prelude_opt.isle line 451.
13785
469
    return v17;
13786
501
}
13787
13788
// Generated as internal constructor for term apply_div_const_magic_s32_shift.
13789
501
pub fn constructor_apply_div_const_magic_s32_shift<C: Context>(
13790
501
    ctx: &mut C,
13791
501
    arg0: &Opcode,
13792
501
    arg1: Value,
13793
501
    arg2: i32,
13794
501
    arg3: &DivConstMagicS32,
13795
501
    arg4: Value,
13796
501
) -> Value {
13797
    if let &DivConstMagicS32::S32 {
13798
501
        mul_by: v4,
13799
501
        shift_by: v5,
13800
501
    } = arg3 {
13801
501
        let v8 = C::u32_into_i64(ctx, v5);
13802
501
        let v9 = constructor_iconst_s(ctx, I32, v8);
13803
501
        let v10 = constructor_sshr(ctx, I32, arg4, v9);
13804
501
        let v12 = constructor_iconst_s(ctx, I32, 31_i64);
13805
501
        let v13 = constructor_ushr(ctx, I32, v10, v12);
13806
501
        let v14 = constructor_iadd(ctx, I32, v10, v13);
13807
501
        let v15 = constructor_apply_div_const_magic_s32_finish(ctx, arg0, arg1, arg2, v14);
13808
        // Rule at src/prelude_opt.isle line 462.
13809
501
        return v15;
13810
    }
13811
    unreachable!("no rule matched for term {} at {}; should it be partial?", "apply_div_const_magic_s32_shift", "src/prelude_opt.isle line 461")
13812
501
}
13813
13814
// Generated as internal constructor for term apply_div_const_magic_s32_finish.
13815
501
pub fn constructor_apply_div_const_magic_s32_finish<C: Context>(
13816
501
    ctx: &mut C,
13817
501
    arg0: &Opcode,
13818
501
    arg1: Value,
13819
501
    arg2: i32,
13820
501
    arg3: Value,
13821
501
) -> Value {
13822
501
    match arg0 {
13823
        &Opcode::Sdiv => {
13824
            // Rule at src/prelude_opt.isle line 486.
13825
501
            return arg3;
13826
        }
13827
        &Opcode::Srem => {
13828
0
            let v5 = C::i32_into_i64(ctx, arg2);
13829
0
            let v6 = constructor_iconst_s(ctx, I32, v5);
13830
0
            let v7 = constructor_imul(ctx, I32, arg3, v6);
13831
0
            let v8 = constructor_isub(ctx, I32, arg1, v7);
13832
            // Rule at src/prelude_opt.isle line 483.
13833
0
            return v8;
13834
        }
13835
0
        _ => {}
13836
    }
13837
0
    unreachable!("no rule matched for term {} at {}; should it be partial?", "apply_div_const_magic_s32_finish", "src/prelude_opt.isle line 482")
13838
501
}
13839
13840
// Generated as internal constructor for term apply_div_const_magic_s64.
13841
0
pub fn constructor_apply_div_const_magic_s64<C: Context>(
13842
0
    ctx: &mut C,
13843
0
    arg0: &Opcode,
13844
0
    arg1: Value,
13845
0
    arg2: i64,
13846
0
) -> Value {
13847
0
    let v3 = &C::div_const_magic_s64(ctx, arg2);
13848
0
    let v4 = constructor_apply_div_const_magic_s64_inner(ctx, arg0, arg1, arg2, v3);
13849
    // Rule at src/prelude_opt.isle line 492.
13850
0
    return v4;
13851
0
}
13852
13853
// Generated as internal constructor for term apply_div_const_magic_s64_inner.
13854
0
pub fn constructor_apply_div_const_magic_s64_inner<C: Context>(
13855
0
    ctx: &mut C,
13856
0
    arg0: &Opcode,
13857
0
    arg1: Value,
13858
0
    arg2: i64,
13859
0
    arg3: &DivConstMagicS64,
13860
0
) -> Value {
13861
    if let &DivConstMagicS64::S64 {
13862
0
        mul_by: v4,
13863
0
        shift_by: v5,
13864
0
    } = arg3 {
13865
0
        let v7 = constructor_iconst_s(ctx, I64, v4);
13866
0
        let v8 = constructor_smulhi(ctx, I64, arg1, v7);
13867
0
        let v9 = constructor_apply_div_const_magic_s64_add_sub(ctx, arg0, arg1, arg2, arg3, v8);
13868
        // Rule at src/prelude_opt.isle line 498.
13869
0
        return v9;
13870
    }
13871
    unreachable!("no rule matched for term {} at {}; should it be partial?", "apply_div_const_magic_s64_inner", "src/prelude_opt.isle line 497")
13872
0
}
13873
13874
// Generated as internal constructor for term apply_div_const_magic_s64_add_sub.
13875
0
pub fn constructor_apply_div_const_magic_s64_add_sub<C: Context>(
13876
0
    ctx: &mut C,
13877
0
    arg0: &Opcode,
13878
0
    arg1: Value,
13879
0
    arg2: i64,
13880
0
    arg3: &DivConstMagicS64,
13881
0
    arg4: Value,
13882
0
) -> Value {
13883
    if let &DivConstMagicS64::S64 {
13884
0
        mul_by: v4,
13885
0
        shift_by: v5,
13886
0
    } = arg3 {
13887
0
        let v8 = C::i64_gt(ctx, arg2, 0_i64);
13888
0
        if v8 == true {
13889
0
            let v9 = C::i64_lt(ctx, v4, 0_i64);
13890
0
            if v9 == true {
13891
0
                let v11 = constructor_iadd(ctx, I64, arg4, arg1);
13892
0
                let v12 = constructor_apply_div_const_magic_s64_shift(ctx, arg0, arg1, arg2, arg3, v11);
13893
                // Rule at src/prelude_opt.isle line 514.
13894
0
                return v12;
13895
0
            }
13896
0
        }
13897
0
        let v13 = C::i64_lt(ctx, arg2, 0_i64);
13898
0
        if v13 == true {
13899
0
            let v14 = C::i64_gt(ctx, v4, 0_i64);
13900
0
            if v14 == true {
13901
0
                let v15 = constructor_isub(ctx, I64, arg4, arg1);
13902
0
                let v16 = constructor_apply_div_const_magic_s64_shift(ctx, arg0, arg1, arg2, arg3, v15);
13903
                // Rule at src/prelude_opt.isle line 523.
13904
0
                return v16;
13905
0
            }
13906
0
        }
13907
    }
13908
0
    let v17 = constructor_apply_div_const_magic_s64_shift(ctx, arg0, arg1, arg2, arg3, arg4);
13909
    // Rule at src/prelude_opt.isle line 532.
13910
0
    return v17;
13911
0
}
13912
13913
// Generated as internal constructor for term apply_div_const_magic_s64_shift.
13914
0
pub fn constructor_apply_div_const_magic_s64_shift<C: Context>(
13915
0
    ctx: &mut C,
13916
0
    arg0: &Opcode,
13917
0
    arg1: Value,
13918
0
    arg2: i64,
13919
0
    arg3: &DivConstMagicS64,
13920
0
    arg4: Value,
13921
0
) -> Value {
13922
    if let &DivConstMagicS64::S64 {
13923
0
        mul_by: v4,
13924
0
        shift_by: v5,
13925
0
    } = arg3 {
13926
0
        let v8 = C::u32_into_i64(ctx, v5);
13927
0
        let v9 = constructor_iconst_s(ctx, I64, v8);
13928
0
        let v10 = constructor_sshr(ctx, I64, arg4, v9);
13929
0
        let v12 = constructor_iconst_s(ctx, I64, 63_i64);
13930
0
        let v13 = constructor_ushr(ctx, I64, v10, v12);
13931
0
        let v14 = constructor_iadd(ctx, I64, v10, v13);
13932
0
        let v15 = constructor_apply_div_const_magic_s64_finish(ctx, arg0, arg1, arg2, v14);
13933
        // Rule at src/prelude_opt.isle line 543.
13934
0
        return v15;
13935
    }
13936
    unreachable!("no rule matched for term {} at {}; should it be partial?", "apply_div_const_magic_s64_shift", "src/prelude_opt.isle line 542")
13937
0
}
13938
13939
// Generated as internal constructor for term apply_div_const_magic_s64_finish.
13940
0
pub fn constructor_apply_div_const_magic_s64_finish<C: Context>(
13941
0
    ctx: &mut C,
13942
0
    arg0: &Opcode,
13943
0
    arg1: Value,
13944
0
    arg2: i64,
13945
0
    arg3: Value,
13946
0
) -> Value {
13947
0
    match arg0 {
13948
        &Opcode::Sdiv => {
13949
            // Rule at src/prelude_opt.isle line 567.
13950
0
            return arg3;
13951
        }
13952
        &Opcode::Srem => {
13953
0
            let v5 = constructor_iconst_s(ctx, I64, arg2);
13954
0
            let v6 = constructor_imul(ctx, I64, arg3, v5);
13955
0
            let v7 = constructor_isub(ctx, I64, arg1, v6);
13956
            // Rule at src/prelude_opt.isle line 564.
13957
0
            return v7;
13958
        }
13959
0
        _ => {}
13960
    }
13961
0
    unreachable!("no rule matched for term {} at {}; should it be partial?", "apply_div_const_magic_s64_finish", "src/prelude_opt.isle line 563")
13962
0
}
13963
13964
// Generated as internal constructor for term truthy.
13965
59.2k
pub fn constructor_truthy<C: Context>(
13966
59.2k
    ctx: &mut C,
13967
59.2k
    arg0: Value,
13968
59.2k
    returns: &mut (impl Extend<Value> + Length),
13969
59.2k
) -> () {
13970
59.2k
    let mut v1 = C::inst_data_value_etor_returns::default();
13971
59.2k
    C::inst_data_value_etor(ctx, arg0, &mut v1);
13972
59.2k
    let mut v1 = v1.into_context_iter();
13973
133k
    while let Some(
v273.9k
) = v1.next(ctx) {
13974
73.9k
        match &v2.1 {
13975
            &InstructionData::Binary {
13976
2.75k
                opcode: ref v7,
13977
2.75k
                args: ref v8,
13978
            } => {
13979
2.75k
                match v7 {
13980
                    &Opcode::Rotl => {
13981
0
                        let v9 = C::unpack_value_array_2(ctx, v8);
13982
                        // Rule at src/opts/bitops.isle line 111.
13983
0
                        returns.extend(Some(v9.0));
13984
0
                        if returns.len() >= MAX_ISLE_RETURNS { return; }
13985
                    }
13986
                    &Opcode::Rotr => {
13987
0
                        let v9 = C::unpack_value_array_2(ctx, v8);
13988
                        // Rule at src/opts/bitops.isle line 112.
13989
0
                        returns.extend(Some(v9.0));
13990
0
                        if returns.len() >= MAX_ISLE_RETURNS { return; }
13991
                    }
13992
2.75k
                    _ => {}
13993
                }
13994
            }
13995
            &InstructionData::IntCompare {
13996
24.6k
                opcode: ref v34,
13997
24.6k
                args: ref v35,
13998
24.6k
                cond: ref v36,
13999
            } => {
14000
24.6k
                if let &Opcode::Icmp = v34 {
14001
24.6k
                    if let &IntCC::NotEqual = v36 {
14002
166
                        let v37 = C::unpack_value_array_2(ctx, v35);
14003
166
                        let mut v40 = C::inst_data_value_etor_returns::default();
14004
166
                        C::inst_data_value_etor(ctx, v37.1, &mut v40);
14005
166
                        let mut v40 = v40.into_context_iter();
14006
335
                        while let Some(
v41169
) = v40.next(ctx) {
14007
                            if let &InstructionData::UnaryImm {
14008
159
                                opcode: ref v44,
14009
159
                                imm: v45,
14010
169
                            } = &v41.1 {
14011
159
                                if let &Opcode::Iconst = v44 {
14012
159
                                    let v46 = C::u64_from_imm64(ctx, v45);
14013
159
                                    if v46 == 0x0_u64 {
14014
                                        // Rule at src/opts/bitops.isle line 115.
14015
159
                                        returns.extend(Some(v37.0));
14016
159
                                        if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
14017
0
                                    }
14018
0
                                }
14019
10
                            }
14020
                        }
14021
24.5k
                    }
14022
0
                }
14023
            }
14024
            &InstructionData::Ternary {
14025
14.8k
                opcode: ref v12,
14026
14.8k
                args: ref v13,
14027
            } => {
14028
14.8k
                if let &Opcode::Select = v12 {
14029
14.8k
                    let v14 = C::unpack_value_array_3(ctx, v13);
14030
14.8k
                    let mut v18 = C::inst_data_value_etor_returns::default();
14031
14.8k
                    C::inst_data_value_etor(ctx, v14.1, &mut v18);
14032
14.8k
                    let mut v18 = v18.into_context_iter();
14033
29.6k
                    while let Some(
v1914.8k
) = v18.next(ctx) {
14034
                        if let &InstructionData::UnaryImm {
14035
628
                            opcode: ref v22,
14036
628
                            imm: v23,
14037
14.8k
                        } = &v19.1 {
14038
628
                            if let &Opcode::Iconst = v22 {
14039
628
                                let v24 = C::u64_from_imm64(ctx, v23);
14040
628
                                let v25 = C::u64_matches_non_zero(ctx, v24);
14041
628
                                if let Some(v26) = v25 {
14042
628
                                    if v26 == true {
14043
622
                                        let mut v27 = C::inst_data_value_etor_returns::default();
14044
622
                                        C::inst_data_value_etor(ctx, v14.2, &mut v27);
14045
622
                                        let mut v27 = v27.into_context_iter();
14046
1.24k
                                        while let Some(
v28622
) = v27.next(ctx) {
14047
                                            if let &InstructionData::UnaryImm {
14048
0
                                                opcode: ref v31,
14049
0
                                                imm: v32,
14050
622
                                            } = &v28.1 {
14051
0
                                                if let &Opcode::Iconst = v31 {
14052
0
                                                    let v33 = C::u64_from_imm64(ctx, v32);
14053
0
                                                    if v33 == 0x0_u64 {
14054
                                                        // Rule at src/opts/bitops.isle line 113.
14055
0
                                                        returns.extend(Some(v14.0));
14056
0
                                                        if returns.len() >= MAX_ISLE_RETURNS { return; }
14057
0
                                                    }
14058
0
                                                }
14059
622
                                            }
14060
                                        }
14061
6
                                    }
14062
0
                                }
14063
0
                            }
14064
14.2k
                        }
14065
                    }
14066
0
                }
14067
            }
14068
            &InstructionData::Unary {
14069
25.9k
                opcode: ref v5,
14070
25.9k
                arg: v6,
14071
            } => {
14072
25.9k
                match v5 {
14073
                    &Opcode::Ineg => {
14074
                        // Rule at src/opts/bitops.isle line 107.
14075
1
                        returns.extend(Some(v6));
14076
1
                        if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
14077
                    }
14078
                    &Opcode::Bitrev => {
14079
                        // Rule at src/opts/bitops.isle line 109.
14080
0
                        returns.extend(Some(v6));
14081
0
                        if returns.len() >= MAX_ISLE_RETURNS { return; }
14082
                    }
14083
                    &Opcode::Bswap => {
14084
                        // Rule at src/opts/bitops.isle line 108.
14085
0
                        returns.extend(Some(v6));
14086
0
                        if returns.len() >= MAX_ISLE_RETURNS { return; }
14087
                    }
14088
                    &Opcode::Popcnt => {
14089
                        // Rule at src/opts/bitops.isle line 110.
14090
0
                        returns.extend(Some(v6));
14091
0
                        if returns.len() >= MAX_ISLE_RETURNS { return; }
14092
                    }
14093
                    &Opcode::Bmask => {
14094
                        // Rule at src/opts/bitops.isle line 106.
14095
0
                        returns.extend(Some(v6));
14096
0
                        if returns.len() >= MAX_ISLE_RETURNS { return; }
14097
                    }
14098
                    &Opcode::Uextend => {
14099
                        // Rule at src/opts/bitops.isle line 105.
14100
25.8k
                        returns.extend(Some(v6));
14101
25.8k
                        if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
14102
                    }
14103
                    &Opcode::Sextend => {
14104
                        // Rule at src/opts/bitops.isle line 104.
14105
54
                        returns.extend(Some(v6));
14106
54
                        if returns.len() >= MAX_ISLE_RETURNS { 
return0
; }
14107
                    }
14108
62
                    _ => {}
14109
                }
14110
            }
14111
5.74k
            _ => {}
14112
        }
14113
    }
14114
59.2k
}
14115
14116
// Generated as internal constructor for term splat8.
14117
0
pub fn constructor_splat8<C: Context>(
14118
0
    ctx: &mut C,
14119
0
    arg0: u64,
14120
0
) -> Constant {
14121
0
    let v2 = C::u64_shl(ctx, arg0, 0x8_u32);
14122
0
    let v3 = C::u64_or(ctx, arg0, v2);
14123
0
    let v4 = constructor_splat16(ctx, v3);
14124
    // Rule at src/opts/cprop.isle line 217.
14125
0
    return v4;
14126
0
}
14127
14128
// Generated as internal constructor for term splat16.
14129
0
pub fn constructor_splat16<C: Context>(
14130
0
    ctx: &mut C,
14131
0
    arg0: u64,
14132
0
) -> Constant {
14133
0
    let v2 = C::u64_shl(ctx, arg0, 0x10_u32);
14134
0
    let v3 = C::u64_or(ctx, arg0, v2);
14135
0
    let v4 = constructor_splat32(ctx, v3);
14136
    // Rule at src/opts/cprop.isle line 219.
14137
0
    return v4;
14138
0
}
14139
14140
// Generated as internal constructor for term splat32.
14141
0
pub fn constructor_splat32<C: Context>(
14142
0
    ctx: &mut C,
14143
0
    arg0: u64,
14144
0
) -> Constant {
14145
0
    let v2 = C::u64_shl(ctx, arg0, 0x20_u32);
14146
0
    let v3 = C::u64_or(ctx, arg0, v2);
14147
0
    let v4 = C::splat64(ctx, v3);
14148
    // Rule at src/opts/cprop.isle line 221.
14149
0
    return v4;
14150
0
}
14151
14152
// Generated as internal constructor for term intcc_comparable.
14153
1.08k
pub fn constructor_intcc_comparable<C: Context>(
14154
1.08k
    ctx: &mut C,
14155
1.08k
    arg0: &IntCC,
14156
1.08k
    arg1: &IntCC,
14157
1.08k
) -> Option<bool> {
14158
1.08k
    let v2 = constructor_intcc_class(ctx, arg0);
14159
1.08k
    let v3 = constructor_intcc_class(ctx, arg1);
14160
1.08k
    let v4 = C::u64_and(ctx, v2, v3);
14161
1.08k
    let v5 = C::u64_matches_non_zero(ctx, v4);
14162
1.08k
    if let Some(v6) = v5 {
14163
1.08k
        if v6 == true {
14164
1.08k
            let v8 = C::u64_eq(ctx, 0x2_u64, v4);
14165
1.08k
            let v9 = Some(v8);
14166
            // Rule at src/opts/icmp.isle line 204.
14167
1.08k
            return v9;
14168
0
        }
14169
0
    }
14170
0
    None
14171
1.08k
}
14172
14173
// Generated as internal constructor for term decompose_intcc.
14174
0
pub fn constructor_decompose_intcc<C: Context>(
14175
0
    ctx: &mut C,
14176
0
    arg0: &IntCC,
14177
0
) -> u64 {
14178
0
    match arg0 {
14179
        &IntCC::Equal => {
14180
            // Rule at src/opts/icmp.isle line 209.
14181
0
            return 0x1_u64;
14182
        }
14183
        &IntCC::NotEqual => {
14184
            // Rule at src/opts/icmp.isle line 218.
14185
0
            return 0x6_u64;
14186
        }
14187
        &IntCC::SignedGreaterThan => {
14188
            // Rule at src/opts/icmp.isle line 215.
14189
0
            return 0x4_u64;
14190
        }
14191
        &IntCC::SignedGreaterThanOrEqual => {
14192
            // Rule at src/opts/icmp.isle line 217.
14193
0
            return 0x5_u64;
14194
        }
14195
        &IntCC::SignedLessThan => {
14196
            // Rule at src/opts/icmp.isle line 211.
14197
0
            return 0x2_u64;
14198
        }
14199
        &IntCC::SignedLessThanOrEqual => {
14200
            // Rule at src/opts/icmp.isle line 213.
14201
0
            return 0x3_u64;
14202
        }
14203
        &IntCC::UnsignedGreaterThan => {
14204
            // Rule at src/opts/icmp.isle line 214.
14205
0
            return 0x4_u64;
14206
        }
14207
        &IntCC::UnsignedGreaterThanOrEqual => {
14208
            // Rule at src/opts/icmp.isle line 216.
14209
0
            return 0x5_u64;
14210
        }
14211
        &IntCC::UnsignedLessThan => {
14212
            // Rule at src/opts/icmp.isle line 210.
14213
0
            return 0x2_u64;
14214
        }
14215
        &IntCC::UnsignedLessThanOrEqual => {
14216
            // Rule at src/opts/icmp.isle line 212.
14217
0
            return 0x3_u64;
14218
        }
14219
0
        _ => {}
14220
    }
14221
0
    unreachable!("no rule matched for term {} at {}; should it be partial?", "decompose_intcc", "src/opts/icmp.isle line 208")
14222
0
}
14223
14224
// Generated as internal constructor for term compose_icmp.
14225
0
pub fn constructor_compose_icmp<C: Context>(
14226
0
    ctx: &mut C,
14227
0
    arg0: Type,
14228
0
    arg1: u64,
14229
0
    arg2: bool,
14230
0
    arg3: Value,
14231
0
    arg4: Value,
14232
0
) -> Value {
14233
0
    match arg1 {
14234
        0x0_u64 => {
14235
0
            let v6 = constructor_iconst_u(ctx, arg0, 0x0_u64);
14236
0
            let v7 = C::subsume(ctx, v6);
14237
            // Rule at src/opts/icmp.isle line 221.
14238
0
            return v7;
14239
        }
14240
        0x1_u64 => {
14241
0
            let v9 = constructor_icmp(ctx, arg0, &IntCC::Equal, arg3, arg4);
14242
            // Rule at src/opts/icmp.isle line 222.
14243
0
            return v9;
14244
        }
14245
        0x2_u64 => {
14246
0
            match arg2 {
14247
                false => {
14248
0
                    let v11 = constructor_icmp(ctx, arg0, &IntCC::UnsignedLessThan, arg3, arg4);
14249
                    // Rule at src/opts/icmp.isle line 223.
14250
0
                    return v11;
14251
                }
14252
                true => {
14253
0
                    let v13 = constructor_icmp(ctx, arg0, &IntCC::SignedLessThan, arg3, arg4);
14254
                    // Rule at src/opts/icmp.isle line 224.
14255
0
                    return v13;
14256
                }
14257
                _ => {}
14258
            }
14259
        }
14260
        0x3_u64 => {
14261
0
            match arg2 {
14262
                false => {
14263
0
                    let v15 = constructor_icmp(ctx, arg0, &IntCC::UnsignedLessThanOrEqual, arg3, arg4);
14264
                    // Rule at src/opts/icmp.isle line 225.
14265
0
                    return v15;
14266
                }
14267
                true => {
14268
0
                    let v17 = constructor_icmp(ctx, arg0, &IntCC::SignedLessThanOrEqual, arg3, arg4);
14269
                    // Rule at src/opts/icmp.isle line 226.
14270
0
                    return v17;
14271
                }
14272
                _ => {}
14273
            }
14274
        }
14275
        0x4_u64 => {
14276
0
            match arg2 {
14277
                false => {
14278
0
                    let v19 = constructor_icmp(ctx, arg0, &IntCC::UnsignedGreaterThan, arg3, arg4);
14279
                    // Rule at src/opts/icmp.isle line 227.
14280
0
                    return v19;
14281
                }
14282
                true => {
14283
0
                    let v21 = constructor_icmp(ctx, arg0, &IntCC::SignedGreaterThan, arg3, arg4);
14284
                    // Rule at src/opts/icmp.isle line 228.
14285
0
                    return v21;
14286
                }
14287
                _ => {}
14288
            }
14289
        }
14290
        0x5_u64 => {
14291
0
            match arg2 {
14292
                false => {
14293
0
                    let v23 = constructor_icmp(ctx, arg0, &IntCC::UnsignedGreaterThanOrEqual, arg3, arg4);
14294
                    // Rule at src/opts/icmp.isle line 229.
14295
0
                    return v23;
14296
                }
14297
                true => {
14298
0
                    let v25 = constructor_icmp(ctx, arg0, &IntCC::SignedGreaterThanOrEqual, arg3, arg4);
14299
                    // Rule at src/opts/icmp.isle line 230.
14300
0
                    return v25;
14301
                }
14302
                _ => {}
14303
            }
14304
        }
14305
        0x6_u64 => {
14306
0
            let v27 = constructor_icmp(ctx, arg0, &IntCC::NotEqual, arg3, arg4);
14307
            // Rule at src/opts/icmp.isle line 231.
14308
0
            return v27;
14309
        }
14310
        0x7_u64 => {
14311
0
            let v29 = constructor_iconst_u(ctx, arg0, 0x1_u64);
14312
0
            let v30 = C::subsume(ctx, v29);
14313
            // Rule at src/opts/icmp.isle line 232.
14314
0
            return v30;
14315
        }
14316
0
        _ => {}
14317
    }
14318
0
    unreachable!("no rule matched for term {} at {}; should it be partial?", "compose_icmp", "src/opts/icmp.isle line 220")
14319
0
}
14320
14321
// Generated as internal constructor for term intcc_class.
14322
2.17k
pub fn constructor_intcc_class<C: Context>(
14323
2.17k
    ctx: &mut C,
14324
2.17k
    arg0: &IntCC,
14325
2.17k
) -> u64 {
14326
2.17k
    match arg0 {
14327
        &IntCC::Equal => {
14328
            // Rule at src/opts/icmp.isle line 243.
14329
840
            return 0x3_u64;
14330
        }
14331
        &IntCC::NotEqual => {
14332
            // Rule at src/opts/icmp.isle line 244.
14333
513
            return 0x3_u64;
14334
        }
14335
        &IntCC::SignedGreaterThan => {
14336
            // Rule at src/opts/icmp.isle line 241.
14337
0
            return 0x2_u64;
14338
        }
14339
        &IntCC::SignedGreaterThanOrEqual => {
14340
            // Rule at src/opts/icmp.isle line 242.
14341
0
            return 0x2_u64;
14342
        }
14343
        &IntCC::SignedLessThan => {
14344
            // Rule at src/opts/icmp.isle line 239.
14345
0
            return 0x2_u64;
14346
        }
14347
        &IntCC::SignedLessThanOrEqual => {
14348
            // Rule at src/opts/icmp.isle line 240.
14349
0
            return 0x2_u64;
14350
        }
14351
        &IntCC::UnsignedGreaterThan => {
14352
            // Rule at src/opts/icmp.isle line 237.
14353
482
            return 0x1_u64;
14354
        }
14355
        &IntCC::UnsignedGreaterThanOrEqual => {
14356
            // Rule at src/opts/icmp.isle line 238.
14357
16
            return 0x1_u64;
14358
        }
14359
        &IntCC::UnsignedLessThan => {
14360
            // Rule at src/opts/icmp.isle line 235.
14361
317
            return 0x1_u64;
14362
        }
14363
        &IntCC::UnsignedLessThanOrEqual => {
14364
            // Rule at src/opts/icmp.isle line 236.
14365
2
            return 0x1_u64;
14366
        }
14367
0
        _ => {}
14368
    }
14369
0
    unreachable!("no rule matched for term {} at {}; should it be partial?", "intcc_class", "src/opts/icmp.isle line 234")
14370
2.17k
}
14371
14372
// Generated as internal constructor for term shift_amt_to_type.
14373
832
pub fn constructor_shift_amt_to_type<C: Context>(
14374
832
    ctx: &mut C,
14375
832
    arg0: u64,
14376
832
) -> Option<Type> {
14377
832
    match arg0 {
14378
        0x8_u64 => {
14379
131
            let v2 = Some(I8);
14380
            // Rule at src/opts/shifts.isle line 93.
14381
131
            return v2;
14382
        }
14383
        0x10_u64 => {
14384
0
            let v4 = Some(I16);
14385
            // Rule at src/opts/shifts.isle line 94.
14386
0
            return v4;
14387
        }
14388
        0x20_u64 => {
14389
0
            let v6 = Some(I32);
14390
            // Rule at src/opts/shifts.isle line 95.
14391
0
            return v6;
14392
        }
14393
701
        _ => {}
14394
    }
14395
701
    None
14396
832
}
14397
14398
// Generated as internal constructor for term iadd_uextend.
14399
0
pub fn constructor_iadd_uextend<C: Context>(
14400
0
    ctx: &mut C,
14401
0
    arg0: Value,
14402
0
    arg1: Value,
14403
0
) -> Value {
14404
0
    let v3 = C::value_type(ctx, arg1);
14405
0
    let v6 = C::ty_bits_u64(ctx, v3);
14406
0
    let v1 = C::value_type(ctx, arg0);
14407
0
    let v5 = C::ty_bits_u64(ctx, v1);
14408
0
    let v10 = C::u64_lt(ctx, v6, v5);
14409
0
    if v10 == true {
14410
0
        let v11 = constructor_uextend(ctx, v1, arg1);
14411
0
        let v12 = constructor_iadd(ctx, v1, arg0, v11);
14412
        // Rule at src/opts/shifts.isle line 214.
14413
0
        return v12;
14414
0
    }
14415
0
    let v7 = C::u64_lt(ctx, v5, v6);
14416
0
    if v7 == true {
14417
0
        let v8 = constructor_uextend(ctx, v3, arg0);
14418
0
        let v9 = constructor_iadd(ctx, v3, v8, arg1);
14419
        // Rule at src/opts/shifts.isle line 211.
14420
0
        return v9;
14421
0
    }
14422
0
    if v1 == v3 {
14423
0
        let v4 = constructor_iadd(ctx, v1, arg0, arg1);
14424
        // Rule at src/opts/shifts.isle line 209.
14425
0
        return v4;
14426
0
    }
14427
0
    unreachable!("no rule matched for term {} at {}; should it be partial?", "iadd_uextend", "src/opts/shifts.isle line 208")
14428
0
}
14429
14430
// Generated as internal constructor for term isub_uextend.
14431
0
pub fn constructor_isub_uextend<C: Context>(
14432
0
    ctx: &mut C,
14433
0
    arg0: Value,
14434
0
    arg1: Value,
14435
0
) -> Value {
14436
0
    let v3 = C::value_type(ctx, arg1);
14437
0
    let v6 = C::ty_bits_u64(ctx, v3);
14438
0
    let v1 = C::value_type(ctx, arg0);
14439
0
    let v5 = C::ty_bits_u64(ctx, v1);
14440
0
    let v10 = C::u64_lt(ctx, v6, v5);
14441
0
    if v10 == true {
14442
0
        let v11 = constructor_uextend(ctx, v1, arg1);
14443
0
        let v12 = constructor_isub(ctx, v1, arg0, v11);
14444
        // Rule at src/opts/shifts.isle line 226.
14445
0
        return v12;
14446
0
    }
14447
0
    let v7 = C::u64_lt(ctx, v5, v6);
14448
0
    if v7 == true {
14449
0
        let v8 = constructor_uextend(ctx, v3, arg0);
14450
0
        let v9 = constructor_isub(ctx, v3, v8, arg1);
14451
        // Rule at src/opts/shifts.isle line 223.
14452
0
        return v9;
14453
0
    }
14454
0
    if v1 == v3 {
14455
0
        let v4 = constructor_isub(ctx, v1, arg0, arg1);
14456
        // Rule at src/opts/shifts.isle line 221.
14457
0
        return v4;
14458
0
    }
14459
0
    unreachable!("no rule matched for term {} at {}; should it be partial?", "isub_uextend", "src/opts/shifts.isle line 220")
14460
0
}
14461
14462
// Generated as internal constructor for term jump.
14463
0
pub fn constructor_jump<C: Context>(
14464
0
    ctx: &mut C,
14465
0
    arg0: BlockCall,
14466
0
) -> Inst {
14467
0
    let v2 = InstructionData::Jump {
14468
0
        opcode: Opcode::Jump,
14469
0
        destination: arg0,
14470
0
    };
14471
0
    let v3 = C::make_skeleton_inst_ctor(ctx, &v2);
14472
    // Rule at <OUT_DIR>/clif_opt.isle line 363.
14473
0
    return v3;
14474
0
}
14475
14476
// Generated as internal constructor for term brif.
14477
0
pub fn constructor_brif<C: Context>(
14478
0
    ctx: &mut C,
14479
0
    arg0: Value,
14480
0
    arg1: BlockCall,
14481
0
    arg2: BlockCall,
14482
0
) -> Inst {
14483
0
    let v4 = &C::pack_block_array_2(ctx, arg1, arg2);
14484
0
    let v5 = InstructionData::Brif {
14485
0
        opcode: Opcode::Brif,
14486
0
        arg: arg0,
14487
0
        blocks: v4.clone(),
14488
0
    };
14489
0
    let v6 = C::make_skeleton_inst_ctor(ctx, &v5);
14490
    // Rule at <OUT_DIR>/clif_opt.isle line 372.
14491
0
    return v6;
14492
0
}
14493
14494
// Generated as internal constructor for term br_table.
14495
0
pub fn constructor_br_table<C: Context>(
14496
0
    ctx: &mut C,
14497
0
    arg0: Value,
14498
0
    arg1: JumpTable,
14499
0
) -> Inst {
14500
0
    let v3 = InstructionData::BranchTable {
14501
0
        opcode: Opcode::BrTable,
14502
0
        arg: arg0,
14503
0
        table: arg1,
14504
0
    };
14505
0
    let v4 = C::make_skeleton_inst_ctor(ctx, &v3);
14506
    // Rule at <OUT_DIR>/clif_opt.isle line 381.
14507
0
    return v4;
14508
0
}
14509
14510
// Generated as internal constructor for term debugtrap.
14511
0
pub fn constructor_debugtrap<C: Context>(
14512
0
    ctx: &mut C,
14513
0
) -> Inst {
14514
0
    let v1 = InstructionData::NullAry {
14515
0
        opcode: Opcode::Debugtrap,
14516
0
    };
14517
0
    let v2 = C::make_skeleton_inst_ctor(ctx, &v1);
14518
    // Rule at <OUT_DIR>/clif_opt.isle line 390.
14519
0
    return v2;
14520
0
}
14521
14522
// Generated as internal constructor for term trap.
14523
0
pub fn constructor_trap<C: Context>(
14524
0
    ctx: &mut C,
14525
0
    arg0: &TrapCode,
14526
0
) -> Inst {
14527
0
    let v2 = InstructionData::Trap {
14528
0
        opcode: Opcode::Trap,
14529
0
        code: arg0.clone(),
14530
0
    };
14531
0
    let v3 = C::make_skeleton_inst_ctor(ctx, &v2);
14532
    // Rule at <OUT_DIR>/clif_opt.isle line 399.
14533
0
    return v3;
14534
0
}
14535
14536
// Generated as internal constructor for term trapz.
14537
0
pub fn constructor_trapz<C: Context>(
14538
0
    ctx: &mut C,
14539
0
    arg0: Value,
14540
0
    arg1: &TrapCode,
14541
0
) -> Inst {
14542
0
    let v3 = InstructionData::CondTrap {
14543
0
        opcode: Opcode::Trapz,
14544
0
        arg: arg0,
14545
0
        code: arg1.clone(),
14546
0
    };
14547
0
    let v4 = C::make_skeleton_inst_ctor(ctx, &v3);
14548
    // Rule at <OUT_DIR>/clif_opt.isle line 408.
14549
0
    return v4;
14550
0
}
14551
14552
// Generated as internal constructor for term trapnz.
14553
0
pub fn constructor_trapnz<C: Context>(
14554
0
    ctx: &mut C,
14555
0
    arg0: Value,
14556
0
    arg1: &TrapCode,
14557
0
) -> Inst {
14558
0
    let v3 = InstructionData::CondTrap {
14559
0
        opcode: Opcode::Trapnz,
14560
0
        arg: arg0,
14561
0
        code: arg1.clone(),
14562
0
    };
14563
0
    let v4 = C::make_skeleton_inst_ctor(ctx, &v3);
14564
    // Rule at <OUT_DIR>/clif_opt.isle line 417.
14565
0
    return v4;
14566
0
}
14567
14568
// Generated as internal constructor for term func_addr.
14569
0
pub fn constructor_func_addr<C: Context>(
14570
0
    ctx: &mut C,
14571
0
    arg0: Type,
14572
0
    arg1: FuncRef,
14573
0
) -> Value {
14574
0
    let v3 = InstructionData::FuncAddr {
14575
0
        opcode: Opcode::FuncAddr,
14576
0
        func_ref: arg1,
14577
0
    };
14578
0
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
14579
    // Rule at <OUT_DIR>/clif_opt.isle line 426.
14580
0
    return v4;
14581
0
}
14582
14583
// Generated as internal constructor for term splat.
14584
0
pub fn constructor_splat<C: Context>(
14585
0
    ctx: &mut C,
14586
0
    arg0: Type,
14587
0
    arg1: Value,
14588
0
) -> Value {
14589
0
    let v3 = InstructionData::Unary {
14590
0
        opcode: Opcode::Splat,
14591
0
        arg: arg1,
14592
0
    };
14593
0
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
14594
    // Rule at <OUT_DIR>/clif_opt.isle line 435.
14595
0
    return v4;
14596
0
}
14597
14598
// Generated as internal constructor for term swizzle.
14599
0
pub fn constructor_swizzle<C: Context>(
14600
0
    ctx: &mut C,
14601
0
    arg0: Type,
14602
0
    arg1: Value,
14603
0
    arg2: Value,
14604
0
) -> Value {
14605
0
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
14606
0
    let v5 = InstructionData::Binary {
14607
0
        opcode: Opcode::Swizzle,
14608
0
        args: v4.clone(),
14609
0
    };
14610
0
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
14611
    // Rule at <OUT_DIR>/clif_opt.isle line 444.
14612
0
    return v6;
14613
0
}
14614
14615
// Generated as internal constructor for term x86_pshufb.
14616
0
pub fn constructor_x86_pshufb<C: Context>(
14617
0
    ctx: &mut C,
14618
0
    arg0: Type,
14619
0
    arg1: Value,
14620
0
    arg2: Value,
14621
0
) -> Value {
14622
0
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
14623
0
    let v5 = InstructionData::Binary {
14624
0
        opcode: Opcode::X86Pshufb,
14625
0
        args: v4.clone(),
14626
0
    };
14627
0
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
14628
    // Rule at <OUT_DIR>/clif_opt.isle line 453.
14629
0
    return v6;
14630
0
}
14631
14632
// Generated as internal constructor for term insertlane.
14633
0
pub fn constructor_insertlane<C: Context>(
14634
0
    ctx: &mut C,
14635
0
    arg0: Type,
14636
0
    arg1: Value,
14637
0
    arg2: Value,
14638
0
    arg3: Uimm8,
14639
0
) -> Value {
14640
0
    let v5 = &C::value_array_2_ctor(ctx, arg1, arg2);
14641
0
    let v6 = InstructionData::TernaryImm8 {
14642
0
        opcode: Opcode::Insertlane,
14643
0
        args: v5.clone(),
14644
0
        imm: arg3,
14645
0
    };
14646
0
    let v7 = C::make_inst_ctor(ctx, arg0, &v6);
14647
    // Rule at <OUT_DIR>/clif_opt.isle line 462.
14648
0
    return v7;
14649
0
}
14650
14651
// Generated as internal constructor for term extractlane.
14652
0
pub fn constructor_extractlane<C: Context>(
14653
0
    ctx: &mut C,
14654
0
    arg0: Type,
14655
0
    arg1: Value,
14656
0
    arg2: Uimm8,
14657
0
) -> Value {
14658
0
    let v4 = InstructionData::BinaryImm8 {
14659
0
        opcode: Opcode::Extractlane,
14660
0
        arg: arg1,
14661
0
        imm: arg2,
14662
0
    };
14663
0
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);
14664
    // Rule at <OUT_DIR>/clif_opt.isle line 471.
14665
0
    return v5;
14666
0
}
14667
14668
// Generated as internal constructor for term smin.
14669
0
pub fn constructor_smin<C: Context>(
14670
0
    ctx: &mut C,
14671
0
    arg0: Type,
14672
0
    arg1: Value,
14673
0
    arg2: Value,
14674
0
) -> Value {
14675
0
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
14676
0
    let v5 = InstructionData::Binary {
14677
0
        opcode: Opcode::Smin,
14678
0
        args: v4.clone(),
14679
0
    };
14680
0
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
14681
    // Rule at <OUT_DIR>/clif_opt.isle line 480.
14682
0
    return v6;
14683
0
}
14684
14685
// Generated as internal constructor for term umin.
14686
1.60k
pub fn constructor_umin<C: Context>(
14687
1.60k
    ctx: &mut C,
14688
1.60k
    arg0: Type,
14689
1.60k
    arg1: Value,
14690
1.60k
    arg2: Value,
14691
1.60k
) -> Value {
14692
1.60k
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
14693
1.60k
    let v5 = InstructionData::Binary {
14694
1.60k
        opcode: Opcode::Umin,
14695
1.60k
        args: v4.clone(),
14696
1.60k
    };
14697
1.60k
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
14698
    // Rule at <OUT_DIR>/clif_opt.isle line 489.
14699
1.60k
    return v6;
14700
1.60k
}
14701
14702
// Generated as internal constructor for term smax.
14703
0
pub fn constructor_smax<C: Context>(
14704
0
    ctx: &mut C,
14705
0
    arg0: Type,
14706
0
    arg1: Value,
14707
0
    arg2: Value,
14708
0
) -> Value {
14709
0
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
14710
0
    let v5 = InstructionData::Binary {
14711
0
        opcode: Opcode::Smax,
14712
0
        args: v4.clone(),
14713
0
    };
14714
0
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
14715
    // Rule at <OUT_DIR>/clif_opt.isle line 498.
14716
0
    return v6;
14717
0
}
14718
14719
// Generated as internal constructor for term umax.
14720
2.81k
pub fn constructor_umax<C: Context>(
14721
2.81k
    ctx: &mut C,
14722
2.81k
    arg0: Type,
14723
2.81k
    arg1: Value,
14724
2.81k
    arg2: Value,
14725
2.81k
) -> Value {
14726
2.81k
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
14727
2.81k
    let v5 = InstructionData::Binary {
14728
2.81k
        opcode: Opcode::Umax,
14729
2.81k
        args: v4.clone(),
14730
2.81k
    };
14731
2.81k
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
14732
    // Rule at <OUT_DIR>/clif_opt.isle line 507.
14733
2.81k
    return v6;
14734
2.81k
}
14735
14736
// Generated as internal constructor for term avg_round.
14737
0
pub fn constructor_avg_round<C: Context>(
14738
0
    ctx: &mut C,
14739
0
    arg0: Type,
14740
0
    arg1: Value,
14741
0
    arg2: Value,
14742
0
) -> Value {
14743
0
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
14744
0
    let v5 = InstructionData::Binary {
14745
0
        opcode: Opcode::AvgRound,
14746
0
        args: v4.clone(),
14747
0
    };
14748
0
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
14749
    // Rule at <OUT_DIR>/clif_opt.isle line 516.
14750
0
    return v6;
14751
0
}
14752
14753
// Generated as internal constructor for term uadd_sat.
14754
0
pub fn constructor_uadd_sat<C: Context>(
14755
0
    ctx: &mut C,
14756
0
    arg0: Type,
14757
0
    arg1: Value,
14758
0
    arg2: Value,
14759
0
) -> Value {
14760
0
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
14761
0
    let v5 = InstructionData::Binary {
14762
0
        opcode: Opcode::UaddSat,
14763
0
        args: v4.clone(),
14764
0
    };
14765
0
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
14766
    // Rule at <OUT_DIR>/clif_opt.isle line 525.
14767
0
    return v6;
14768
0
}
14769
14770
// Generated as internal constructor for term sadd_sat.
14771
0
pub fn constructor_sadd_sat<C: Context>(
14772
0
    ctx: &mut C,
14773
0
    arg0: Type,
14774
0
    arg1: Value,
14775
0
    arg2: Value,
14776
0
) -> Value {
14777
0
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
14778
0
    let v5 = InstructionData::Binary {
14779
0
        opcode: Opcode::SaddSat,
14780
0
        args: v4.clone(),
14781
0
    };
14782
0
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
14783
    // Rule at <OUT_DIR>/clif_opt.isle line 534.
14784
0
    return v6;
14785
0
}
14786
14787
// Generated as internal constructor for term usub_sat.
14788
0
pub fn constructor_usub_sat<C: Context>(
14789
0
    ctx: &mut C,
14790
0
    arg0: Type,
14791
0
    arg1: Value,
14792
0
    arg2: Value,
14793
0
) -> Value {
14794
0
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
14795
0
    let v5 = InstructionData::Binary {
14796
0
        opcode: Opcode::UsubSat,
14797
0
        args: v4.clone(),
14798
0
    };
14799
0
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
14800
    // Rule at <OUT_DIR>/clif_opt.isle line 543.
14801
0
    return v6;
14802
0
}
14803
14804
// Generated as internal constructor for term ssub_sat.
14805
0
pub fn constructor_ssub_sat<C: Context>(
14806
0
    ctx: &mut C,
14807
0
    arg0: Type,
14808
0
    arg1: Value,
14809
0
    arg2: Value,
14810
0
) -> Value {
14811
0
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
14812
0
    let v5 = InstructionData::Binary {
14813
0
        opcode: Opcode::SsubSat,
14814
0
        args: v4.clone(),
14815
0
    };
14816
0
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
14817
    // Rule at <OUT_DIR>/clif_opt.isle line 552.
14818
0
    return v6;
14819
0
}
14820
14821
// Generated as internal constructor for term load.
14822
0
pub fn constructor_load<C: Context>(
14823
0
    ctx: &mut C,
14824
0
    arg0: Type,
14825
0
    arg1: MemFlags,
14826
0
    arg2: Value,
14827
0
    arg3: Offset32,
14828
0
) -> Value {
14829
0
    let v5 = InstructionData::Load {
14830
0
        opcode: Opcode::Load,
14831
0
        arg: arg2,
14832
0
        flags: arg1,
14833
0
        offset: arg3,
14834
0
    };
14835
0
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
14836
    // Rule at <OUT_DIR>/clif_opt.isle line 561.
14837
0
    return v6;
14838
0
}
14839
14840
// Generated as internal constructor for term store.
14841
0
pub fn constructor_store<C: Context>(
14842
0
    ctx: &mut C,
14843
0
    arg0: MemFlags,
14844
0
    arg1: Value,
14845
0
    arg2: Value,
14846
0
    arg3: Offset32,
14847
0
) -> Inst {
14848
0
    let v5 = &C::value_array_2_ctor(ctx, arg1, arg2);
14849
0
    let v6 = InstructionData::Store {
14850
0
        opcode: Opcode::Store,
14851
0
        args: v5.clone(),
14852
0
        flags: arg0,
14853
0
        offset: arg3,
14854
0
    };
14855
0
    let v7 = C::make_skeleton_inst_ctor(ctx, &v6);
14856
    // Rule at <OUT_DIR>/clif_opt.isle line 570.
14857
0
    return v7;
14858
0
}
14859
14860
// Generated as internal constructor for term uload8.
14861
0
pub fn constructor_uload8<C: Context>(
14862
0
    ctx: &mut C,
14863
0
    arg0: Type,
14864
0
    arg1: MemFlags,
14865
0
    arg2: Value,
14866
0
    arg3: Offset32,
14867
0
) -> Value {
14868
0
    let v5 = InstructionData::Load {
14869
0
        opcode: Opcode::Uload8,
14870
0
        arg: arg2,
14871
0
        flags: arg1,
14872
0
        offset: arg3,
14873
0
    };
14874
0
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
14875
    // Rule at <OUT_DIR>/clif_opt.isle line 579.
14876
0
    return v6;
14877
0
}
14878
14879
// Generated as internal constructor for term sload8.
14880
0
pub fn constructor_sload8<C: Context>(
14881
0
    ctx: &mut C,
14882
0
    arg0: Type,
14883
0
    arg1: MemFlags,
14884
0
    arg2: Value,
14885
0
    arg3: Offset32,
14886
0
) -> Value {
14887
0
    let v5 = InstructionData::Load {
14888
0
        opcode: Opcode::Sload8,
14889
0
        arg: arg2,
14890
0
        flags: arg1,
14891
0
        offset: arg3,
14892
0
    };
14893
0
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
14894
    // Rule at <OUT_DIR>/clif_opt.isle line 588.
14895
0
    return v6;
14896
0
}
14897
14898
// Generated as internal constructor for term istore8.
14899
0
pub fn constructor_istore8<C: Context>(
14900
0
    ctx: &mut C,
14901
0
    arg0: MemFlags,
14902
0
    arg1: Value,
14903
0
    arg2: Value,
14904
0
    arg3: Offset32,
14905
0
) -> Inst {
14906
0
    let v5 = &C::value_array_2_ctor(ctx, arg1, arg2);
14907
0
    let v6 = InstructionData::Store {
14908
0
        opcode: Opcode::Istore8,
14909
0
        args: v5.clone(),
14910
0
        flags: arg0,
14911
0
        offset: arg3,
14912
0
    };
14913
0
    let v7 = C::make_skeleton_inst_ctor(ctx, &v6);
14914
    // Rule at <OUT_DIR>/clif_opt.isle line 597.
14915
0
    return v7;
14916
0
}
14917
14918
// Generated as internal constructor for term uload16.
14919
0
pub fn constructor_uload16<C: Context>(
14920
0
    ctx: &mut C,
14921
0
    arg0: Type,
14922
0
    arg1: MemFlags,
14923
0
    arg2: Value,
14924
0
    arg3: Offset32,
14925
0
) -> Value {
14926
0
    let v5 = InstructionData::Load {
14927
0
        opcode: Opcode::Uload16,
14928
0
        arg: arg2,
14929
0
        flags: arg1,
14930
0
        offset: arg3,
14931
0
    };
14932
0
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
14933
    // Rule at <OUT_DIR>/clif_opt.isle line 606.
14934
0
    return v6;
14935
0
}
14936
14937
// Generated as internal constructor for term sload16.
14938
0
pub fn constructor_sload16<C: Context>(
14939
0
    ctx: &mut C,
14940
0
    arg0: Type,
14941
0
    arg1: MemFlags,
14942
0
    arg2: Value,
14943
0
    arg3: Offset32,
14944
0
) -> Value {
14945
0
    let v5 = InstructionData::Load {
14946
0
        opcode: Opcode::Sload16,
14947
0
        arg: arg2,
14948
0
        flags: arg1,
14949
0
        offset: arg3,
14950
0
    };
14951
0
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
14952
    // Rule at <OUT_DIR>/clif_opt.isle line 615.
14953
0
    return v6;
14954
0
}
14955
14956
// Generated as internal constructor for term istore16.
14957
0
pub fn constructor_istore16<C: Context>(
14958
0
    ctx: &mut C,
14959
0
    arg0: MemFlags,
14960
0
    arg1: Value,
14961
0
    arg2: Value,
14962
0
    arg3: Offset32,
14963
0
) -> Inst {
14964
0
    let v5 = &C::value_array_2_ctor(ctx, arg1, arg2);
14965
0
    let v6 = InstructionData::Store {
14966
0
        opcode: Opcode::Istore16,
14967
0
        args: v5.clone(),
14968
0
        flags: arg0,
14969
0
        offset: arg3,
14970
0
    };
14971
0
    let v7 = C::make_skeleton_inst_ctor(ctx, &v6);
14972
    // Rule at <OUT_DIR>/clif_opt.isle line 624.
14973
0
    return v7;
14974
0
}
14975
14976
// Generated as internal constructor for term uload32.
14977
0
pub fn constructor_uload32<C: Context>(
14978
0
    ctx: &mut C,
14979
0
    arg0: Type,
14980
0
    arg1: MemFlags,
14981
0
    arg2: Value,
14982
0
    arg3: Offset32,
14983
0
) -> Value {
14984
0
    let v5 = InstructionData::Load {
14985
0
        opcode: Opcode::Uload32,
14986
0
        arg: arg2,
14987
0
        flags: arg1,
14988
0
        offset: arg3,
14989
0
    };
14990
0
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
14991
    // Rule at <OUT_DIR>/clif_opt.isle line 633.
14992
0
    return v6;
14993
0
}
14994
14995
// Generated as internal constructor for term sload32.
14996
0
pub fn constructor_sload32<C: Context>(
14997
0
    ctx: &mut C,
14998
0
    arg0: Type,
14999
0
    arg1: MemFlags,
15000
0
    arg2: Value,
15001
0
    arg3: Offset32,
15002
0
) -> Value {
15003
0
    let v5 = InstructionData::Load {
15004
0
        opcode: Opcode::Sload32,
15005
0
        arg: arg2,
15006
0
        flags: arg1,
15007
0
        offset: arg3,
15008
0
    };
15009
0
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
15010
    // Rule at <OUT_DIR>/clif_opt.isle line 642.
15011
0
    return v6;
15012
0
}
15013
15014
// Generated as internal constructor for term istore32.
15015
0
pub fn constructor_istore32<C: Context>(
15016
0
    ctx: &mut C,
15017
0
    arg0: MemFlags,
15018
0
    arg1: Value,
15019
0
    arg2: Value,
15020
0
    arg3: Offset32,
15021
0
) -> Inst {
15022
0
    let v5 = &C::value_array_2_ctor(ctx, arg1, arg2);
15023
0
    let v6 = InstructionData::Store {
15024
0
        opcode: Opcode::Istore32,
15025
0
        args: v5.clone(),
15026
0
        flags: arg0,
15027
0
        offset: arg3,
15028
0
    };
15029
0
    let v7 = C::make_skeleton_inst_ctor(ctx, &v6);
15030
    // Rule at <OUT_DIR>/clif_opt.isle line 651.
15031
0
    return v7;
15032
0
}
15033
15034
// Generated as internal constructor for term stack_switch.
15035
0
pub fn constructor_stack_switch<C: Context>(
15036
0
    ctx: &mut C,
15037
0
    arg0: Value,
15038
0
    arg1: Value,
15039
0
    arg2: Value,
15040
0
) -> Inst {
15041
0
    let v4 = &C::value_array_3_ctor(ctx, arg0, arg1, arg2);
15042
0
    let v5 = InstructionData::Ternary {
15043
0
        opcode: Opcode::StackSwitch,
15044
0
        args: v4.clone(),
15045
0
    };
15046
0
    let v6 = C::make_skeleton_inst_ctor(ctx, &v5);
15047
    // Rule at <OUT_DIR>/clif_opt.isle line 660.
15048
0
    return v6;
15049
0
}
15050
15051
// Generated as internal constructor for term uload8x8.
15052
0
pub fn constructor_uload8x8<C: Context>(
15053
0
    ctx: &mut C,
15054
0
    arg0: Type,
15055
0
    arg1: MemFlags,
15056
0
    arg2: Value,
15057
0
    arg3: Offset32,
15058
0
) -> Value {
15059
0
    let v5 = InstructionData::Load {
15060
0
        opcode: Opcode::Uload8x8,
15061
0
        arg: arg2,
15062
0
        flags: arg1,
15063
0
        offset: arg3,
15064
0
    };
15065
0
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
15066
    // Rule at <OUT_DIR>/clif_opt.isle line 669.
15067
0
    return v6;
15068
0
}
15069
15070
// Generated as internal constructor for term sload8x8.
15071
0
pub fn constructor_sload8x8<C: Context>(
15072
0
    ctx: &mut C,
15073
0
    arg0: Type,
15074
0
    arg1: MemFlags,
15075
0
    arg2: Value,
15076
0
    arg3: Offset32,
15077
0
) -> Value {
15078
0
    let v5 = InstructionData::Load {
15079
0
        opcode: Opcode::Sload8x8,
15080
0
        arg: arg2,
15081
0
        flags: arg1,
15082
0
        offset: arg3,
15083
0
    };
15084
0
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
15085
    // Rule at <OUT_DIR>/clif_opt.isle line 678.
15086
0
    return v6;
15087
0
}
15088
15089
// Generated as internal constructor for term uload16x4.
15090
0
pub fn constructor_uload16x4<C: Context>(
15091
0
    ctx: &mut C,
15092
0
    arg0: Type,
15093
0
    arg1: MemFlags,
15094
0
    arg2: Value,
15095
0
    arg3: Offset32,
15096
0
) -> Value {
15097
0
    let v5 = InstructionData::Load {
15098
0
        opcode: Opcode::Uload16x4,
15099
0
        arg: arg2,
15100
0
        flags: arg1,
15101
0
        offset: arg3,
15102
0
    };
15103
0
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
15104
    // Rule at <OUT_DIR>/clif_opt.isle line 687.
15105
0
    return v6;
15106
0
}
15107
15108
// Generated as internal constructor for term sload16x4.
15109
0
pub fn constructor_sload16x4<C: Context>(
15110
0
    ctx: &mut C,
15111
0
    arg0: Type,
15112
0
    arg1: MemFlags,
15113
0
    arg2: Value,
15114
0
    arg3: Offset32,
15115
0
) -> Value {
15116
0
    let v5 = InstructionData::Load {
15117
0
        opcode: Opcode::Sload16x4,
15118
0
        arg: arg2,
15119
0
        flags: arg1,
15120
0
        offset: arg3,
15121
0
    };
15122
0
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
15123
    // Rule at <OUT_DIR>/clif_opt.isle line 696.
15124
0
    return v6;
15125
0
}
15126
15127
// Generated as internal constructor for term uload32x2.
15128
0
pub fn constructor_uload32x2<C: Context>(
15129
0
    ctx: &mut C,
15130
0
    arg0: Type,
15131
0
    arg1: MemFlags,
15132
0
    arg2: Value,
15133
0
    arg3: Offset32,
15134
0
) -> Value {
15135
0
    let v5 = InstructionData::Load {
15136
0
        opcode: Opcode::Uload32x2,
15137
0
        arg: arg2,
15138
0
        flags: arg1,
15139
0
        offset: arg3,
15140
0
    };
15141
0
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
15142
    // Rule at <OUT_DIR>/clif_opt.isle line 705.
15143
0
    return v6;
15144
0
}
15145
15146
// Generated as internal constructor for term sload32x2.
15147
0
pub fn constructor_sload32x2<C: Context>(
15148
0
    ctx: &mut C,
15149
0
    arg0: Type,
15150
0
    arg1: MemFlags,
15151
0
    arg2: Value,
15152
0
    arg3: Offset32,
15153
0
) -> Value {
15154
0
    let v5 = InstructionData::Load {
15155
0
        opcode: Opcode::Sload32x2,
15156
0
        arg: arg2,
15157
0
        flags: arg1,
15158
0
        offset: arg3,
15159
0
    };
15160
0
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
15161
    // Rule at <OUT_DIR>/clif_opt.isle line 714.
15162
0
    return v6;
15163
0
}
15164
15165
// Generated as internal constructor for term stack_load.
15166
0
pub fn constructor_stack_load<C: Context>(
15167
0
    ctx: &mut C,
15168
0
    arg0: Type,
15169
0
    arg1: StackSlot,
15170
0
    arg2: Offset32,
15171
0
) -> Value {
15172
0
    let v4 = InstructionData::StackLoad {
15173
0
        opcode: Opcode::StackLoad,
15174
0
        stack_slot: arg1,
15175
0
        offset: arg2,
15176
0
    };
15177
0
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);
15178
    // Rule at <OUT_DIR>/clif_opt.isle line 723.
15179
0
    return v5;
15180
0
}
15181
15182
// Generated as internal constructor for term stack_store.
15183
0
pub fn constructor_stack_store<C: Context>(
15184
0
    ctx: &mut C,
15185
0
    arg0: Value,
15186
0
    arg1: StackSlot,
15187
0
    arg2: Offset32,
15188
0
) -> Inst {
15189
0
    let v4 = InstructionData::StackStore {
15190
0
        opcode: Opcode::StackStore,
15191
0
        arg: arg0,
15192
0
        stack_slot: arg1,
15193
0
        offset: arg2,
15194
0
    };
15195
0
    let v5 = C::make_skeleton_inst_ctor(ctx, &v4);
15196
    // Rule at <OUT_DIR>/clif_opt.isle line 732.
15197
0
    return v5;
15198
0
}
15199
15200
// Generated as internal constructor for term stack_addr.
15201
0
pub fn constructor_stack_addr<C: Context>(
15202
0
    ctx: &mut C,
15203
0
    arg0: Type,
15204
0
    arg1: StackSlot,
15205
0
    arg2: Offset32,
15206
0
) -> Value {
15207
0
    let v4 = InstructionData::StackLoad {
15208
0
        opcode: Opcode::StackAddr,
15209
0
        stack_slot: arg1,
15210
0
        offset: arg2,
15211
0
    };
15212
0
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);
15213
    // Rule at <OUT_DIR>/clif_opt.isle line 741.
15214
0
    return v5;
15215
0
}
15216
15217
// Generated as internal constructor for term dynamic_stack_load.
15218
0
pub fn constructor_dynamic_stack_load<C: Context>(
15219
0
    ctx: &mut C,
15220
0
    arg0: Type,
15221
0
    arg1: DynamicStackSlot,
15222
0
) -> Value {
15223
0
    let v3 = InstructionData::DynamicStackLoad {
15224
0
        opcode: Opcode::DynamicStackLoad,
15225
0
        dynamic_stack_slot: arg1,
15226
0
    };
15227
0
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
15228
    // Rule at <OUT_DIR>/clif_opt.isle line 750.
15229
0
    return v4;
15230
0
}
15231
15232
// Generated as internal constructor for term dynamic_stack_store.
15233
0
pub fn constructor_dynamic_stack_store<C: Context>(
15234
0
    ctx: &mut C,
15235
0
    arg0: Value,
15236
0
    arg1: DynamicStackSlot,
15237
0
) -> Inst {
15238
0
    let v3 = InstructionData::DynamicStackStore {
15239
0
        opcode: Opcode::DynamicStackStore,
15240
0
        arg: arg0,
15241
0
        dynamic_stack_slot: arg1,
15242
0
    };
15243
0
    let v4 = C::make_skeleton_inst_ctor(ctx, &v3);
15244
    // Rule at <OUT_DIR>/clif_opt.isle line 759.
15245
0
    return v4;
15246
0
}
15247
15248
// Generated as internal constructor for term dynamic_stack_addr.
15249
0
pub fn constructor_dynamic_stack_addr<C: Context>(
15250
0
    ctx: &mut C,
15251
0
    arg0: Type,
15252
0
    arg1: DynamicStackSlot,
15253
0
) -> Value {
15254
0
    let v3 = InstructionData::DynamicStackLoad {
15255
0
        opcode: Opcode::DynamicStackAddr,
15256
0
        dynamic_stack_slot: arg1,
15257
0
    };
15258
0
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
15259
    // Rule at <OUT_DIR>/clif_opt.isle line 768.
15260
0
    return v4;
15261
0
}
15262
15263
// Generated as internal constructor for term global_value.
15264
0
pub fn constructor_global_value<C: Context>(
15265
0
    ctx: &mut C,
15266
0
    arg0: Type,
15267
0
    arg1: GlobalValue,
15268
0
) -> Value {
15269
0
    let v3 = InstructionData::UnaryGlobalValue {
15270
0
        opcode: Opcode::GlobalValue,
15271
0
        global_value: arg1,
15272
0
    };
15273
0
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
15274
    // Rule at <OUT_DIR>/clif_opt.isle line 777.
15275
0
    return v4;
15276
0
}
15277
15278
// Generated as internal constructor for term symbol_value.
15279
0
pub fn constructor_symbol_value<C: Context>(
15280
0
    ctx: &mut C,
15281
0
    arg0: Type,
15282
0
    arg1: GlobalValue,
15283
0
) -> Value {
15284
0
    let v3 = InstructionData::UnaryGlobalValue {
15285
0
        opcode: Opcode::SymbolValue,
15286
0
        global_value: arg1,
15287
0
    };
15288
0
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
15289
    // Rule at <OUT_DIR>/clif_opt.isle line 786.
15290
0
    return v4;
15291
0
}
15292
15293
// Generated as internal constructor for term tls_value.
15294
0
pub fn constructor_tls_value<C: Context>(
15295
0
    ctx: &mut C,
15296
0
    arg0: Type,
15297
0
    arg1: GlobalValue,
15298
0
) -> Value {
15299
0
    let v3 = InstructionData::UnaryGlobalValue {
15300
0
        opcode: Opcode::TlsValue,
15301
0
        global_value: arg1,
15302
0
    };
15303
0
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
15304
    // Rule at <OUT_DIR>/clif_opt.isle line 795.
15305
0
    return v4;
15306
0
}
15307
15308
// Generated as internal constructor for term get_pinned_reg.
15309
0
pub fn constructor_get_pinned_reg<C: Context>(
15310
0
    ctx: &mut C,
15311
0
) -> Inst {
15312
0
    let v1 = InstructionData::NullAry {
15313
0
        opcode: Opcode::GetPinnedReg,
15314
0
    };
15315
0
    let v2 = C::make_skeleton_inst_ctor(ctx, &v1);
15316
    // Rule at <OUT_DIR>/clif_opt.isle line 804.
15317
0
    return v2;
15318
0
}
15319
15320
// Generated as internal constructor for term set_pinned_reg.
15321
0
pub fn constructor_set_pinned_reg<C: Context>(
15322
0
    ctx: &mut C,
15323
0
    arg0: Value,
15324
0
) -> Inst {
15325
0
    let v2 = InstructionData::Unary {
15326
0
        opcode: Opcode::SetPinnedReg,
15327
0
        arg: arg0,
15328
0
    };
15329
0
    let v3 = C::make_skeleton_inst_ctor(ctx, &v2);
15330
    // Rule at <OUT_DIR>/clif_opt.isle line 813.
15331
0
    return v3;
15332
0
}
15333
15334
// Generated as internal constructor for term get_frame_pointer.
15335
0
pub fn constructor_get_frame_pointer<C: Context>(
15336
0
    ctx: &mut C,
15337
0
    arg0: Type,
15338
0
) -> Value {
15339
0
    let v2 = InstructionData::NullAry {
15340
0
        opcode: Opcode::GetFramePointer,
15341
0
    };
15342
0
    let v3 = C::make_inst_ctor(ctx, arg0, &v2);
15343
    // Rule at <OUT_DIR>/clif_opt.isle line 822.
15344
0
    return v3;
15345
0
}
15346
15347
// Generated as internal constructor for term get_stack_pointer.
15348
0
pub fn constructor_get_stack_pointer<C: Context>(
15349
0
    ctx: &mut C,
15350
0
    arg0: Type,
15351
0
) -> Value {
15352
0
    let v2 = InstructionData::NullAry {
15353
0
        opcode: Opcode::GetStackPointer,
15354
0
    };
15355
0
    let v3 = C::make_inst_ctor(ctx, arg0, &v2);
15356
    // Rule at <OUT_DIR>/clif_opt.isle line 831.
15357
0
    return v3;
15358
0
}
15359
15360
// Generated as internal constructor for term get_return_address.
15361
0
pub fn constructor_get_return_address<C: Context>(
15362
0
    ctx: &mut C,
15363
0
    arg0: Type,
15364
0
) -> Value {
15365
0
    let v2 = InstructionData::NullAry {
15366
0
        opcode: Opcode::GetReturnAddress,
15367
0
    };
15368
0
    let v3 = C::make_inst_ctor(ctx, arg0, &v2);
15369
    // Rule at <OUT_DIR>/clif_opt.isle line 840.
15370
0
    return v3;
15371
0
}
15372
15373
// Generated as internal constructor for term iconst.
15374
989k
pub fn constructor_iconst<C: Context>(
15375
989k
    ctx: &mut C,
15376
989k
    arg0: Type,
15377
989k
    arg1: Imm64,
15378
989k
) -> Value {
15379
989k
    let v3 = InstructionData::UnaryImm {
15380
989k
        opcode: Opcode::Iconst,
15381
989k
        imm: arg1,
15382
989k
    };
15383
989k
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
15384
    // Rule at <OUT_DIR>/clif_opt.isle line 849.
15385
989k
    return v4;
15386
989k
}
15387
15388
// Generated as internal constructor for term f16const.
15389
0
pub fn constructor_f16const<C: Context>(
15390
0
    ctx: &mut C,
15391
0
    arg0: Type,
15392
0
    arg1: Ieee16,
15393
0
) -> Value {
15394
0
    let v3 = InstructionData::UnaryIeee16 {
15395
0
        opcode: Opcode::F16const,
15396
0
        imm: arg1,
15397
0
    };
15398
0
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
15399
    // Rule at <OUT_DIR>/clif_opt.isle line 858.
15400
0
    return v4;
15401
0
}
15402
15403
// Generated as internal constructor for term f32const.
15404
0
pub fn constructor_f32const<C: Context>(
15405
0
    ctx: &mut C,
15406
0
    arg0: Type,
15407
0
    arg1: Ieee32,
15408
0
) -> Value {
15409
0
    let v3 = InstructionData::UnaryIeee32 {
15410
0
        opcode: Opcode::F32const,
15411
0
        imm: arg1,
15412
0
    };
15413
0
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
15414
    // Rule at <OUT_DIR>/clif_opt.isle line 867.
15415
0
    return v4;
15416
0
}
15417
15418
// Generated as internal constructor for term f64const.
15419
0
pub fn constructor_f64const<C: Context>(
15420
0
    ctx: &mut C,
15421
0
    arg0: Type,
15422
0
    arg1: Ieee64,
15423
0
) -> Value {
15424
0
    let v3 = InstructionData::UnaryIeee64 {
15425
0
        opcode: Opcode::F64const,
15426
0
        imm: arg1,
15427
0
    };
15428
0
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
15429
    // Rule at <OUT_DIR>/clif_opt.isle line 876.
15430
0
    return v4;
15431
0
}
15432
15433
// Generated as internal constructor for term f128const.
15434
0
pub fn constructor_f128const<C: Context>(
15435
0
    ctx: &mut C,
15436
0
    arg0: Type,
15437
0
    arg1: Constant,
15438
0
) -> Value {
15439
0
    let v3 = InstructionData::UnaryConst {
15440
0
        opcode: Opcode::F128const,
15441
0
        constant_handle: arg1,
15442
0
    };
15443
0
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
15444
    // Rule at <OUT_DIR>/clif_opt.isle line 885.
15445
0
    return v4;
15446
0
}
15447
15448
// Generated as internal constructor for term vconst.
15449
0
pub fn constructor_vconst<C: Context>(
15450
0
    ctx: &mut C,
15451
0
    arg0: Type,
15452
0
    arg1: Constant,
15453
0
) -> Value {
15454
0
    let v3 = InstructionData::UnaryConst {
15455
0
        opcode: Opcode::Vconst,
15456
0
        constant_handle: arg1,
15457
0
    };
15458
0
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
15459
    // Rule at <OUT_DIR>/clif_opt.isle line 894.
15460
0
    return v4;
15461
0
}
15462
15463
// Generated as internal constructor for term shuffle.
15464
0
pub fn constructor_shuffle<C: Context>(
15465
0
    ctx: &mut C,
15466
0
    arg0: Type,
15467
0
    arg1: Value,
15468
0
    arg2: Value,
15469
0
    arg3: Immediate,
15470
0
) -> Value {
15471
0
    let v5 = &C::value_array_2_ctor(ctx, arg1, arg2);
15472
0
    let v6 = InstructionData::Shuffle {
15473
0
        opcode: Opcode::Shuffle,
15474
0
        args: v5.clone(),
15475
0
        imm: arg3,
15476
0
    };
15477
0
    let v7 = C::make_inst_ctor(ctx, arg0, &v6);
15478
    // Rule at <OUT_DIR>/clif_opt.isle line 903.
15479
0
    return v7;
15480
0
}
15481
15482
// Generated as internal constructor for term nop.
15483
0
pub fn constructor_nop<C: Context>(
15484
0
    ctx: &mut C,
15485
0
) -> Inst {
15486
0
    let v1 = InstructionData::NullAry {
15487
0
        opcode: Opcode::Nop,
15488
0
    };
15489
0
    let v2 = C::make_skeleton_inst_ctor(ctx, &v1);
15490
    // Rule at <OUT_DIR>/clif_opt.isle line 912.
15491
0
    return v2;
15492
0
}
15493
15494
// Generated as internal constructor for term select.
15495
55.8k
pub fn constructor_select<C: Context>(
15496
55.8k
    ctx: &mut C,
15497
55.8k
    arg0: Type,
15498
55.8k
    arg1: Value,
15499
55.8k
    arg2: Value,
15500
55.8k
    arg3: Value,
15501
55.8k
) -> Value {
15502
55.8k
    let v5 = &C::value_array_3_ctor(ctx, arg1, arg2, arg3);
15503
55.8k
    let v6 = InstructionData::Ternary {
15504
55.8k
        opcode: Opcode::Select,
15505
55.8k
        args: v5.clone(),
15506
55.8k
    };
15507
55.8k
    let v7 = C::make_inst_ctor(ctx, arg0, &v6);
15508
    // Rule at <OUT_DIR>/clif_opt.isle line 921.
15509
55.8k
    return v7;
15510
55.8k
}
15511
15512
// Generated as internal constructor for term select_spectre_guard.
15513
0
pub fn constructor_select_spectre_guard<C: Context>(
15514
0
    ctx: &mut C,
15515
0
    arg0: Type,
15516
0
    arg1: Value,
15517
0
    arg2: Value,
15518
0
    arg3: Value,
15519
0
) -> Value {
15520
0
    let v5 = &C::value_array_3_ctor(ctx, arg1, arg2, arg3);
15521
0
    let v6 = InstructionData::Ternary {
15522
0
        opcode: Opcode::SelectSpectreGuard,
15523
0
        args: v5.clone(),
15524
0
    };
15525
0
    let v7 = C::make_inst_ctor(ctx, arg0, &v6);
15526
    // Rule at <OUT_DIR>/clif_opt.isle line 930.
15527
0
    return v7;
15528
0
}
15529
15530
// Generated as internal constructor for term bitselect.
15531
0
pub fn constructor_bitselect<C: Context>(
15532
0
    ctx: &mut C,
15533
0
    arg0: Type,
15534
0
    arg1: Value,
15535
0
    arg2: Value,
15536
0
    arg3: Value,
15537
0
) -> Value {
15538
0
    let v5 = &C::value_array_3_ctor(ctx, arg1, arg2, arg3);
15539
0
    let v6 = InstructionData::Ternary {
15540
0
        opcode: Opcode::Bitselect,
15541
0
        args: v5.clone(),
15542
0
    };
15543
0
    let v7 = C::make_inst_ctor(ctx, arg0, &v6);
15544
    // Rule at <OUT_DIR>/clif_opt.isle line 939.
15545
0
    return v7;
15546
0
}
15547
15548
// Generated as internal constructor for term x86_blendv.
15549
0
pub fn constructor_x86_blendv<C: Context>(
15550
0
    ctx: &mut C,
15551
0
    arg0: Type,
15552
0
    arg1: Value,
15553
0
    arg2: Value,
15554
0
    arg3: Value,
15555
0
) -> Value {
15556
0
    let v5 = &C::value_array_3_ctor(ctx, arg1, arg2, arg3);
15557
0
    let v6 = InstructionData::Ternary {
15558
0
        opcode: Opcode::X86Blendv,
15559
0
        args: v5.clone(),
15560
0
    };
15561
0
    let v7 = C::make_inst_ctor(ctx, arg0, &v6);
15562
    // Rule at <OUT_DIR>/clif_opt.isle line 948.
15563
0
    return v7;
15564
0
}
15565
15566
// Generated as internal constructor for term vany_true.
15567
0
pub fn constructor_vany_true<C: Context>(
15568
0
    ctx: &mut C,
15569
0
    arg0: Type,
15570
0
    arg1: Value,
15571
0
) -> Value {
15572
0
    let v3 = InstructionData::Unary {
15573
0
        opcode: Opcode::VanyTrue,
15574
0
        arg: arg1,
15575
0
    };
15576
0
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
15577
    // Rule at <OUT_DIR>/clif_opt.isle line 957.
15578
0
    return v4;
15579
0
}
15580
15581
// Generated as internal constructor for term vall_true.
15582
0
pub fn constructor_vall_true<C: Context>(
15583
0
    ctx: &mut C,
15584
0
    arg0: Type,
15585
0
    arg1: Value,
15586
0
) -> Value {
15587
0
    let v3 = InstructionData::Unary {
15588
0
        opcode: Opcode::VallTrue,
15589
0
        arg: arg1,
15590
0
    };
15591
0
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
15592
    // Rule at <OUT_DIR>/clif_opt.isle line 966.
15593
0
    return v4;
15594
0
}
15595
15596
// Generated as internal constructor for term vhigh_bits.
15597
0
pub fn constructor_vhigh_bits<C: Context>(
15598
0
    ctx: &mut C,
15599
0
    arg0: Type,
15600
0
    arg1: Value,
15601
0
) -> Value {
15602
0
    let v3 = InstructionData::Unary {
15603
0
        opcode: Opcode::VhighBits,
15604
0
        arg: arg1,
15605
0
    };
15606
0
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
15607
    // Rule at <OUT_DIR>/clif_opt.isle line 975.
15608
0
    return v4;
15609
0
}
15610
15611
// Generated as internal constructor for term icmp.
15612
10.5k
pub fn constructor_icmp<C: Context>(
15613
10.5k
    ctx: &mut C,
15614
10.5k
    arg0: Type,
15615
10.5k
    arg1: &IntCC,
15616
10.5k
    arg2: Value,
15617
10.5k
    arg3: Value,
15618
10.5k
) -> Value {
15619
10.5k
    let v5 = &C::value_array_2_ctor(ctx, arg2, arg3);
15620
10.5k
    let v6 = InstructionData::IntCompare {
15621
10.5k
        opcode: Opcode::Icmp,
15622
10.5k
        args: v5.clone(),
15623
10.5k
        cond: arg1.clone(),
15624
10.5k
    };
15625
10.5k
    let v7 = C::make_inst_ctor(ctx, arg0, &v6);
15626
    // Rule at <OUT_DIR>/clif_opt.isle line 984.
15627
10.5k
    return v7;
15628
10.5k
}
15629
15630
// Generated as internal constructor for term icmp_imm.
15631
0
pub fn constructor_icmp_imm<C: Context>(
15632
0
    ctx: &mut C,
15633
0
    arg0: Type,
15634
0
    arg1: &IntCC,
15635
0
    arg2: Value,
15636
0
    arg3: Imm64,
15637
0
) -> Value {
15638
0
    let v5 = InstructionData::IntCompareImm {
15639
0
        opcode: Opcode::IcmpImm,
15640
0
        arg: arg2,
15641
0
        cond: arg1.clone(),
15642
0
        imm: arg3,
15643
0
    };
15644
0
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
15645
    // Rule at <OUT_DIR>/clif_opt.isle line 993.
15646
0
    return v6;
15647
0
}
15648
15649
// Generated as internal constructor for term iadd.
15650
1.47M
pub fn constructor_iadd<C: Context>(
15651
1.47M
    ctx: &mut C,
15652
1.47M
    arg0: Type,
15653
1.47M
    arg1: Value,
15654
1.47M
    arg2: Value,
15655
1.47M
) -> Value {
15656
1.47M
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
15657
1.47M
    let v5 = InstructionData::Binary {
15658
1.47M
        opcode: Opcode::Iadd,
15659
1.47M
        args: v4.clone(),
15660
1.47M
    };
15661
1.47M
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
15662
    // Rule at <OUT_DIR>/clif_opt.isle line 1002.
15663
1.47M
    return v6;
15664
1.47M
}
15665
15666
// Generated as internal constructor for term isub.
15667
104k
pub fn constructor_isub<C: Context>(
15668
104k
    ctx: &mut C,
15669
104k
    arg0: Type,
15670
104k
    arg1: Value,
15671
104k
    arg2: Value,
15672
104k
) -> Value {
15673
104k
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
15674
104k
    let v5 = InstructionData::Binary {
15675
104k
        opcode: Opcode::Isub,
15676
104k
        args: v4.clone(),
15677
104k
    };
15678
104k
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
15679
    // Rule at <OUT_DIR>/clif_opt.isle line 1011.
15680
104k
    return v6;
15681
104k
}
15682
15683
// Generated as internal constructor for term ineg.
15684
26.9k
pub fn constructor_ineg<C: Context>(
15685
26.9k
    ctx: &mut C,
15686
26.9k
    arg0: Type,
15687
26.9k
    arg1: Value,
15688
26.9k
) -> Value {
15689
26.9k
    let v3 = InstructionData::Unary {
15690
26.9k
        opcode: Opcode::Ineg,
15691
26.9k
        arg: arg1,
15692
26.9k
    };
15693
26.9k
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
15694
    // Rule at <OUT_DIR>/clif_opt.isle line 1020.
15695
26.9k
    return v4;
15696
26.9k
}
15697
15698
// Generated as internal constructor for term iabs.
15699
0
pub fn constructor_iabs<C: Context>(
15700
0
    ctx: &mut C,
15701
0
    arg0: Type,
15702
0
    arg1: Value,
15703
0
) -> Value {
15704
0
    let v3 = InstructionData::Unary {
15705
0
        opcode: Opcode::Iabs,
15706
0
        arg: arg1,
15707
0
    };
15708
0
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
15709
    // Rule at <OUT_DIR>/clif_opt.isle line 1029.
15710
0
    return v4;
15711
0
}
15712
15713
// Generated as internal constructor for term imul.
15714
3.19k
pub fn constructor_imul<C: Context>(
15715
3.19k
    ctx: &mut C,
15716
3.19k
    arg0: Type,
15717
3.19k
    arg1: Value,
15718
3.19k
    arg2: Value,
15719
3.19k
) -> Value {
15720
3.19k
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
15721
3.19k
    let v5 = InstructionData::Binary {
15722
3.19k
        opcode: Opcode::Imul,
15723
3.19k
        args: v4.clone(),
15724
3.19k
    };
15725
3.19k
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
15726
    // Rule at <OUT_DIR>/clif_opt.isle line 1038.
15727
3.19k
    return v6;
15728
3.19k
}
15729
15730
// Generated as internal constructor for term umulhi.
15731
3.25k
pub fn constructor_umulhi<C: Context>(
15732
3.25k
    ctx: &mut C,
15733
3.25k
    arg0: Type,
15734
3.25k
    arg1: Value,
15735
3.25k
    arg2: Value,
15736
3.25k
) -> Value {
15737
3.25k
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
15738
3.25k
    let v5 = InstructionData::Binary {
15739
3.25k
        opcode: Opcode::Umulhi,
15740
3.25k
        args: v4.clone(),
15741
3.25k
    };
15742
3.25k
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
15743
    // Rule at <OUT_DIR>/clif_opt.isle line 1047.
15744
3.25k
    return v6;
15745
3.25k
}
15746
15747
// Generated as internal constructor for term smulhi.
15748
501
pub fn constructor_smulhi<C: Context>(
15749
501
    ctx: &mut C,
15750
501
    arg0: Type,
15751
501
    arg1: Value,
15752
501
    arg2: Value,
15753
501
) -> Value {
15754
501
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
15755
501
    let v5 = InstructionData::Binary {
15756
501
        opcode: Opcode::Smulhi,
15757
501
        args: v4.clone(),
15758
501
    };
15759
501
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
15760
    // Rule at <OUT_DIR>/clif_opt.isle line 1056.
15761
501
    return v6;
15762
501
}
15763
15764
// Generated as internal constructor for term sqmul_round_sat.
15765
0
pub fn constructor_sqmul_round_sat<C: Context>(
15766
0
    ctx: &mut C,
15767
0
    arg0: Type,
15768
0
    arg1: Value,
15769
0
    arg2: Value,
15770
0
) -> Value {
15771
0
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
15772
0
    let v5 = InstructionData::Binary {
15773
0
        opcode: Opcode::SqmulRoundSat,
15774
0
        args: v4.clone(),
15775
0
    };
15776
0
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
15777
    // Rule at <OUT_DIR>/clif_opt.isle line 1065.
15778
0
    return v6;
15779
0
}
15780
15781
// Generated as internal constructor for term x86_pmulhrsw.
15782
0
pub fn constructor_x86_pmulhrsw<C: Context>(
15783
0
    ctx: &mut C,
15784
0
    arg0: Type,
15785
0
    arg1: Value,
15786
0
    arg2: Value,
15787
0
) -> Value {
15788
0
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
15789
0
    let v5 = InstructionData::Binary {
15790
0
        opcode: Opcode::X86Pmulhrsw,
15791
0
        args: v4.clone(),
15792
0
    };
15793
0
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
15794
    // Rule at <OUT_DIR>/clif_opt.isle line 1074.
15795
0
    return v6;
15796
0
}
15797
15798
// Generated as internal constructor for term udiv.
15799
0
pub fn constructor_udiv<C: Context>(
15800
0
    ctx: &mut C,
15801
0
    arg0: Value,
15802
0
    arg1: Value,
15803
0
) -> Inst {
15804
0
    let v3 = &C::value_array_2_ctor(ctx, arg0, arg1);
15805
0
    let v4 = InstructionData::Binary {
15806
0
        opcode: Opcode::Udiv,
15807
0
        args: v3.clone(),
15808
0
    };
15809
0
    let v5 = C::make_skeleton_inst_ctor(ctx, &v4);
15810
    // Rule at <OUT_DIR>/clif_opt.isle line 1083.
15811
0
    return v5;
15812
0
}
15813
15814
// Generated as internal constructor for term sdiv.
15815
0
pub fn constructor_sdiv<C: Context>(
15816
0
    ctx: &mut C,
15817
0
    arg0: Value,
15818
0
    arg1: Value,
15819
0
) -> Inst {
15820
0
    let v3 = &C::value_array_2_ctor(ctx, arg0, arg1);
15821
0
    let v4 = InstructionData::Binary {
15822
0
        opcode: Opcode::Sdiv,
15823
0
        args: v3.clone(),
15824
0
    };
15825
0
    let v5 = C::make_skeleton_inst_ctor(ctx, &v4);
15826
    // Rule at <OUT_DIR>/clif_opt.isle line 1092.
15827
0
    return v5;
15828
0
}
15829
15830
// Generated as internal constructor for term urem.
15831
0
pub fn constructor_urem<C: Context>(
15832
0
    ctx: &mut C,
15833
0
    arg0: Value,
15834
0
    arg1: Value,
15835
0
) -> Inst {
15836
0
    let v3 = &C::value_array_2_ctor(ctx, arg0, arg1);
15837
0
    let v4 = InstructionData::Binary {
15838
0
        opcode: Opcode::Urem,
15839
0
        args: v3.clone(),
15840
0
    };
15841
0
    let v5 = C::make_skeleton_inst_ctor(ctx, &v4);
15842
    // Rule at <OUT_DIR>/clif_opt.isle line 1101.
15843
0
    return v5;
15844
0
}
15845
15846
// Generated as internal constructor for term srem.
15847
0
pub fn constructor_srem<C: Context>(
15848
0
    ctx: &mut C,
15849
0
    arg0: Value,
15850
0
    arg1: Value,
15851
0
) -> Inst {
15852
0
    let v3 = &C::value_array_2_ctor(ctx, arg0, arg1);
15853
0
    let v4 = InstructionData::Binary {
15854
0
        opcode: Opcode::Srem,
15855
0
        args: v3.clone(),
15856
0
    };
15857
0
    let v5 = C::make_skeleton_inst_ctor(ctx, &v4);
15858
    // Rule at <OUT_DIR>/clif_opt.isle line 1110.
15859
0
    return v5;
15860
0
}
15861
15862
// Generated as internal constructor for term iadd_imm.
15863
0
pub fn constructor_iadd_imm<C: Context>(
15864
0
    ctx: &mut C,
15865
0
    arg0: Type,
15866
0
    arg1: Value,
15867
0
    arg2: Imm64,
15868
0
) -> Value {
15869
0
    let v4 = InstructionData::BinaryImm64 {
15870
0
        opcode: Opcode::IaddImm,
15871
0
        arg: arg1,
15872
0
        imm: arg2,
15873
0
    };
15874
0
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);
15875
    // Rule at <OUT_DIR>/clif_opt.isle line 1119.
15876
0
    return v5;
15877
0
}
15878
15879
// Generated as internal constructor for term imul_imm.
15880
0
pub fn constructor_imul_imm<C: Context>(
15881
0
    ctx: &mut C,
15882
0
    arg0: Type,
15883
0
    arg1: Value,
15884
0
    arg2: Imm64,
15885
0
) -> Value {
15886
0
    let v4 = InstructionData::BinaryImm64 {
15887
0
        opcode: Opcode::ImulImm,
15888
0
        arg: arg1,
15889
0
        imm: arg2,
15890
0
    };
15891
0
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);
15892
    // Rule at <OUT_DIR>/clif_opt.isle line 1128.
15893
0
    return v5;
15894
0
}
15895
15896
// Generated as internal constructor for term udiv_imm.
15897
0
pub fn constructor_udiv_imm<C: Context>(
15898
0
    ctx: &mut C,
15899
0
    arg0: Type,
15900
0
    arg1: Value,
15901
0
    arg2: Imm64,
15902
0
) -> Value {
15903
0
    let v4 = InstructionData::BinaryImm64 {
15904
0
        opcode: Opcode::UdivImm,
15905
0
        arg: arg1,
15906
0
        imm: arg2,
15907
0
    };
15908
0
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);
15909
    // Rule at <OUT_DIR>/clif_opt.isle line 1137.
15910
0
    return v5;
15911
0
}
15912
15913
// Generated as internal constructor for term sdiv_imm.
15914
0
pub fn constructor_sdiv_imm<C: Context>(
15915
0
    ctx: &mut C,
15916
0
    arg0: Type,
15917
0
    arg1: Value,
15918
0
    arg2: Imm64,
15919
0
) -> Value {
15920
0
    let v4 = InstructionData::BinaryImm64 {
15921
0
        opcode: Opcode::SdivImm,
15922
0
        arg: arg1,
15923
0
        imm: arg2,
15924
0
    };
15925
0
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);
15926
    // Rule at <OUT_DIR>/clif_opt.isle line 1146.
15927
0
    return v5;
15928
0
}
15929
15930
// Generated as internal constructor for term urem_imm.
15931
0
pub fn constructor_urem_imm<C: Context>(
15932
0
    ctx: &mut C,
15933
0
    arg0: Type,
15934
0
    arg1: Value,
15935
0
    arg2: Imm64,
15936
0
) -> Value {
15937
0
    let v4 = InstructionData::BinaryImm64 {
15938
0
        opcode: Opcode::UremImm,
15939
0
        arg: arg1,
15940
0
        imm: arg2,
15941
0
    };
15942
0
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);
15943
    // Rule at <OUT_DIR>/clif_opt.isle line 1155.
15944
0
    return v5;
15945
0
}
15946
15947
// Generated as internal constructor for term srem_imm.
15948
0
pub fn constructor_srem_imm<C: Context>(
15949
0
    ctx: &mut C,
15950
0
    arg0: Type,
15951
0
    arg1: Value,
15952
0
    arg2: Imm64,
15953
0
) -> Value {
15954
0
    let v4 = InstructionData::BinaryImm64 {
15955
0
        opcode: Opcode::SremImm,
15956
0
        arg: arg1,
15957
0
        imm: arg2,
15958
0
    };
15959
0
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);
15960
    // Rule at <OUT_DIR>/clif_opt.isle line 1164.
15961
0
    return v5;
15962
0
}
15963
15964
// Generated as internal constructor for term irsub_imm.
15965
0
pub fn constructor_irsub_imm<C: Context>(
15966
0
    ctx: &mut C,
15967
0
    arg0: Type,
15968
0
    arg1: Value,
15969
0
    arg2: Imm64,
15970
0
) -> Value {
15971
0
    let v4 = InstructionData::BinaryImm64 {
15972
0
        opcode: Opcode::IrsubImm,
15973
0
        arg: arg1,
15974
0
        imm: arg2,
15975
0
    };
15976
0
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);
15977
    // Rule at <OUT_DIR>/clif_opt.isle line 1173.
15978
0
    return v5;
15979
0
}
15980
15981
// Generated as internal constructor for term sadd_overflow_cin.
15982
0
pub fn constructor_sadd_overflow_cin<C: Context>(
15983
0
    ctx: &mut C,
15984
0
    arg0: Value,
15985
0
    arg1: Value,
15986
0
    arg2: Value,
15987
0
) -> Inst {
15988
0
    let v4 = &C::value_array_3_ctor(ctx, arg0, arg1, arg2);
15989
0
    let v5 = InstructionData::Ternary {
15990
0
        opcode: Opcode::SaddOverflowCin,
15991
0
        args: v4.clone(),
15992
0
    };
15993
0
    let v6 = C::make_skeleton_inst_ctor(ctx, &v5);
15994
    // Rule at <OUT_DIR>/clif_opt.isle line 1182.
15995
0
    return v6;
15996
0
}
15997
15998
// Generated as internal constructor for term uadd_overflow_cin.
15999
0
pub fn constructor_uadd_overflow_cin<C: Context>(
16000
0
    ctx: &mut C,
16001
0
    arg0: Value,
16002
0
    arg1: Value,
16003
0
    arg2: Value,
16004
0
) -> Inst {
16005
0
    let v4 = &C::value_array_3_ctor(ctx, arg0, arg1, arg2);
16006
0
    let v5 = InstructionData::Ternary {
16007
0
        opcode: Opcode::UaddOverflowCin,
16008
0
        args: v4.clone(),
16009
0
    };
16010
0
    let v6 = C::make_skeleton_inst_ctor(ctx, &v5);
16011
    // Rule at <OUT_DIR>/clif_opt.isle line 1191.
16012
0
    return v6;
16013
0
}
16014
16015
// Generated as internal constructor for term uadd_overflow.
16016
0
pub fn constructor_uadd_overflow<C: Context>(
16017
0
    ctx: &mut C,
16018
0
    arg0: Value,
16019
0
    arg1: Value,
16020
0
) -> Inst {
16021
0
    let v3 = &C::value_array_2_ctor(ctx, arg0, arg1);
16022
0
    let v4 = InstructionData::Binary {
16023
0
        opcode: Opcode::UaddOverflow,
16024
0
        args: v3.clone(),
16025
0
    };
16026
0
    let v5 = C::make_skeleton_inst_ctor(ctx, &v4);
16027
    // Rule at <OUT_DIR>/clif_opt.isle line 1200.
16028
0
    return v5;
16029
0
}
16030
16031
// Generated as internal constructor for term sadd_overflow.
16032
0
pub fn constructor_sadd_overflow<C: Context>(
16033
0
    ctx: &mut C,
16034
0
    arg0: Value,
16035
0
    arg1: Value,
16036
0
) -> Inst {
16037
0
    let v3 = &C::value_array_2_ctor(ctx, arg0, arg1);
16038
0
    let v4 = InstructionData::Binary {
16039
0
        opcode: Opcode::SaddOverflow,
16040
0
        args: v3.clone(),
16041
0
    };
16042
0
    let v5 = C::make_skeleton_inst_ctor(ctx, &v4);
16043
    // Rule at <OUT_DIR>/clif_opt.isle line 1209.
16044
0
    return v5;
16045
0
}
16046
16047
// Generated as internal constructor for term usub_overflow.
16048
0
pub fn constructor_usub_overflow<C: Context>(
16049
0
    ctx: &mut C,
16050
0
    arg0: Value,
16051
0
    arg1: Value,
16052
0
) -> Inst {
16053
0
    let v3 = &C::value_array_2_ctor(ctx, arg0, arg1);
16054
0
    let v4 = InstructionData::Binary {
16055
0
        opcode: Opcode::UsubOverflow,
16056
0
        args: v3.clone(),
16057
0
    };
16058
0
    let v5 = C::make_skeleton_inst_ctor(ctx, &v4);
16059
    // Rule at <OUT_DIR>/clif_opt.isle line 1218.
16060
0
    return v5;
16061
0
}
16062
16063
// Generated as internal constructor for term ssub_overflow.
16064
0
pub fn constructor_ssub_overflow<C: Context>(
16065
0
    ctx: &mut C,
16066
0
    arg0: Value,
16067
0
    arg1: Value,
16068
0
) -> Inst {
16069
0
    let v3 = &C::value_array_2_ctor(ctx, arg0, arg1);
16070
0
    let v4 = InstructionData::Binary {
16071
0
        opcode: Opcode::SsubOverflow,
16072
0
        args: v3.clone(),
16073
0
    };
16074
0
    let v5 = C::make_skeleton_inst_ctor(ctx, &v4);
16075
    // Rule at <OUT_DIR>/clif_opt.isle line 1227.
16076
0
    return v5;
16077
0
}
16078
16079
// Generated as internal constructor for term umul_overflow.
16080
0
pub fn constructor_umul_overflow<C: Context>(
16081
0
    ctx: &mut C,
16082
0
    arg0: Value,
16083
0
    arg1: Value,
16084
0
) -> Inst {
16085
0
    let v3 = &C::value_array_2_ctor(ctx, arg0, arg1);
16086
0
    let v4 = InstructionData::Binary {
16087
0
        opcode: Opcode::UmulOverflow,
16088
0
        args: v3.clone(),
16089
0
    };
16090
0
    let v5 = C::make_skeleton_inst_ctor(ctx, &v4);
16091
    // Rule at <OUT_DIR>/clif_opt.isle line 1236.
16092
0
    return v5;
16093
0
}
16094
16095
// Generated as internal constructor for term smul_overflow.
16096
0
pub fn constructor_smul_overflow<C: Context>(
16097
0
    ctx: &mut C,
16098
0
    arg0: Value,
16099
0
    arg1: Value,
16100
0
) -> Inst {
16101
0
    let v3 = &C::value_array_2_ctor(ctx, arg0, arg1);
16102
0
    let v4 = InstructionData::Binary {
16103
0
        opcode: Opcode::SmulOverflow,
16104
0
        args: v3.clone(),
16105
0
    };
16106
0
    let v5 = C::make_skeleton_inst_ctor(ctx, &v4);
16107
    // Rule at <OUT_DIR>/clif_opt.isle line 1245.
16108
0
    return v5;
16109
0
}
16110
16111
// Generated as internal constructor for term uadd_overflow_trap.
16112
0
pub fn constructor_uadd_overflow_trap<C: Context>(
16113
0
    ctx: &mut C,
16114
0
    arg0: Value,
16115
0
    arg1: Value,
16116
0
    arg2: &TrapCode,
16117
0
) -> Inst {
16118
0
    let v4 = &C::value_array_2_ctor(ctx, arg0, arg1);
16119
0
    let v5 = InstructionData::IntAddTrap {
16120
0
        opcode: Opcode::UaddOverflowTrap,
16121
0
        args: v4.clone(),
16122
0
        code: arg2.clone(),
16123
0
    };
16124
0
    let v6 = C::make_skeleton_inst_ctor(ctx, &v5);
16125
    // Rule at <OUT_DIR>/clif_opt.isle line 1254.
16126
0
    return v6;
16127
0
}
16128
16129
// Generated as internal constructor for term ssub_overflow_bin.
16130
0
pub fn constructor_ssub_overflow_bin<C: Context>(
16131
0
    ctx: &mut C,
16132
0
    arg0: Value,
16133
0
    arg1: Value,
16134
0
    arg2: Value,
16135
0
) -> Inst {
16136
0
    let v4 = &C::value_array_3_ctor(ctx, arg0, arg1, arg2);
16137
0
    let v5 = InstructionData::Ternary {
16138
0
        opcode: Opcode::SsubOverflowBin,
16139
0
        args: v4.clone(),
16140
0
    };
16141
0
    let v6 = C::make_skeleton_inst_ctor(ctx, &v5);
16142
    // Rule at <OUT_DIR>/clif_opt.isle line 1263.
16143
0
    return v6;
16144
0
}
16145
16146
// Generated as internal constructor for term usub_overflow_bin.
16147
0
pub fn constructor_usub_overflow_bin<C: Context>(
16148
0
    ctx: &mut C,
16149
0
    arg0: Value,
16150
0
    arg1: Value,
16151
0
    arg2: Value,
16152
0
) -> Inst {
16153
0
    let v4 = &C::value_array_3_ctor(ctx, arg0, arg1, arg2);
16154
0
    let v5 = InstructionData::Ternary {
16155
0
        opcode: Opcode::UsubOverflowBin,
16156
0
        args: v4.clone(),
16157
0
    };
16158
0
    let v6 = C::make_skeleton_inst_ctor(ctx, &v5);
16159
    // Rule at <OUT_DIR>/clif_opt.isle line 1272.
16160
0
    return v6;
16161
0
}
16162
16163
// Generated as internal constructor for term band.
16164
16.9k
pub fn constructor_band<C: Context>(
16165
16.9k
    ctx: &mut C,
16166
16.9k
    arg0: Type,
16167
16.9k
    arg1: Value,
16168
16.9k
    arg2: Value,
16169
16.9k
) -> Value {
16170
16.9k
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
16171
16.9k
    let v5 = InstructionData::Binary {
16172
16.9k
        opcode: Opcode::Band,
16173
16.9k
        args: v4.clone(),
16174
16.9k
    };
16175
16.9k
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
16176
    // Rule at <OUT_DIR>/clif_opt.isle line 1281.
16177
16.9k
    return v6;
16178
16.9k
}
16179
16180
// Generated as internal constructor for term bor.
16181
23.1k
pub fn constructor_bor<C: Context>(
16182
23.1k
    ctx: &mut C,
16183
23.1k
    arg0: Type,
16184
23.1k
    arg1: Value,
16185
23.1k
    arg2: Value,
16186
23.1k
) -> Value {
16187
23.1k
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
16188
23.1k
    let v5 = InstructionData::Binary {
16189
23.1k
        opcode: Opcode::Bor,
16190
23.1k
        args: v4.clone(),
16191
23.1k
    };
16192
23.1k
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
16193
    // Rule at <OUT_DIR>/clif_opt.isle line 1290.
16194
23.1k
    return v6;
16195
23.1k
}
16196
16197
// Generated as internal constructor for term bxor.
16198
3.43k
pub fn constructor_bxor<C: Context>(
16199
3.43k
    ctx: &mut C,
16200
3.43k
    arg0: Type,
16201
3.43k
    arg1: Value,
16202
3.43k
    arg2: Value,
16203
3.43k
) -> Value {
16204
3.43k
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
16205
3.43k
    let v5 = InstructionData::Binary {
16206
3.43k
        opcode: Opcode::Bxor,
16207
3.43k
        args: v4.clone(),
16208
3.43k
    };
16209
3.43k
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
16210
    // Rule at <OUT_DIR>/clif_opt.isle line 1299.
16211
3.43k
    return v6;
16212
3.43k
}
16213
16214
// Generated as internal constructor for term bnot.
16215
1.51k
pub fn constructor_bnot<C: Context>(
16216
1.51k
    ctx: &mut C,
16217
1.51k
    arg0: Type,
16218
1.51k
    arg1: Value,
16219
1.51k
) -> Value {
16220
1.51k
    let v3 = InstructionData::Unary {
16221
1.51k
        opcode: Opcode::Bnot,
16222
1.51k
        arg: arg1,
16223
1.51k
    };
16224
1.51k
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
16225
    // Rule at <OUT_DIR>/clif_opt.isle line 1308.
16226
1.51k
    return v4;
16227
1.51k
}
16228
16229
// Generated as internal constructor for term band_not.
16230
0
pub fn constructor_band_not<C: Context>(
16231
0
    ctx: &mut C,
16232
0
    arg0: Type,
16233
0
    arg1: Value,
16234
0
    arg2: Value,
16235
0
) -> Value {
16236
0
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
16237
0
    let v5 = InstructionData::Binary {
16238
0
        opcode: Opcode::BandNot,
16239
0
        args: v4.clone(),
16240
0
    };
16241
0
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
16242
    // Rule at <OUT_DIR>/clif_opt.isle line 1317.
16243
0
    return v6;
16244
0
}
16245
16246
// Generated as internal constructor for term bor_not.
16247
0
pub fn constructor_bor_not<C: Context>(
16248
0
    ctx: &mut C,
16249
0
    arg0: Type,
16250
0
    arg1: Value,
16251
0
    arg2: Value,
16252
0
) -> Value {
16253
0
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
16254
0
    let v5 = InstructionData::Binary {
16255
0
        opcode: Opcode::BorNot,
16256
0
        args: v4.clone(),
16257
0
    };
16258
0
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
16259
    // Rule at <OUT_DIR>/clif_opt.isle line 1326.
16260
0
    return v6;
16261
0
}
16262
16263
// Generated as internal constructor for term bxor_not.
16264
0
pub fn constructor_bxor_not<C: Context>(
16265
0
    ctx: &mut C,
16266
0
    arg0: Type,
16267
0
    arg1: Value,
16268
0
    arg2: Value,
16269
0
) -> Value {
16270
0
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
16271
0
    let v5 = InstructionData::Binary {
16272
0
        opcode: Opcode::BxorNot,
16273
0
        args: v4.clone(),
16274
0
    };
16275
0
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
16276
    // Rule at <OUT_DIR>/clif_opt.isle line 1335.
16277
0
    return v6;
16278
0
}
16279
16280
// Generated as internal constructor for term band_imm.
16281
0
pub fn constructor_band_imm<C: Context>(
16282
0
    ctx: &mut C,
16283
0
    arg0: Type,
16284
0
    arg1: Value,
16285
0
    arg2: Imm64,
16286
0
) -> Value {
16287
0
    let v4 = InstructionData::BinaryImm64 {
16288
0
        opcode: Opcode::BandImm,
16289
0
        arg: arg1,
16290
0
        imm: arg2,
16291
0
    };
16292
0
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);
16293
    // Rule at <OUT_DIR>/clif_opt.isle line 1344.
16294
0
    return v5;
16295
0
}
16296
16297
// Generated as internal constructor for term bor_imm.
16298
0
pub fn constructor_bor_imm<C: Context>(
16299
0
    ctx: &mut C,
16300
0
    arg0: Type,
16301
0
    arg1: Value,
16302
0
    arg2: Imm64,
16303
0
) -> Value {
16304
0
    let v4 = InstructionData::BinaryImm64 {
16305
0
        opcode: Opcode::BorImm,
16306
0
        arg: arg1,
16307
0
        imm: arg2,
16308
0
    };
16309
0
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);
16310
    // Rule at <OUT_DIR>/clif_opt.isle line 1353.
16311
0
    return v5;
16312
0
}
16313
16314
// Generated as internal constructor for term bxor_imm.
16315
0
pub fn constructor_bxor_imm<C: Context>(
16316
0
    ctx: &mut C,
16317
0
    arg0: Type,
16318
0
    arg1: Value,
16319
0
    arg2: Imm64,
16320
0
) -> Value {
16321
0
    let v4 = InstructionData::BinaryImm64 {
16322
0
        opcode: Opcode::BxorImm,
16323
0
        arg: arg1,
16324
0
        imm: arg2,
16325
0
    };
16326
0
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);
16327
    // Rule at <OUT_DIR>/clif_opt.isle line 1362.
16328
0
    return v5;
16329
0
}
16330
16331
// Generated as internal constructor for term rotl.
16332
0
pub fn constructor_rotl<C: Context>(
16333
0
    ctx: &mut C,
16334
0
    arg0: Type,
16335
0
    arg1: Value,
16336
0
    arg2: Value,
16337
0
) -> Value {
16338
0
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
16339
0
    let v5 = InstructionData::Binary {
16340
0
        opcode: Opcode::Rotl,
16341
0
        args: v4.clone(),
16342
0
    };
16343
0
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
16344
    // Rule at <OUT_DIR>/clif_opt.isle line 1371.
16345
0
    return v6;
16346
0
}
16347
16348
// Generated as internal constructor for term rotr.
16349
0
pub fn constructor_rotr<C: Context>(
16350
0
    ctx: &mut C,
16351
0
    arg0: Type,
16352
0
    arg1: Value,
16353
0
    arg2: Value,
16354
0
) -> Value {
16355
0
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
16356
0
    let v5 = InstructionData::Binary {
16357
0
        opcode: Opcode::Rotr,
16358
0
        args: v4.clone(),
16359
0
    };
16360
0
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
16361
    // Rule at <OUT_DIR>/clif_opt.isle line 1380.
16362
0
    return v6;
16363
0
}
16364
16365
// Generated as internal constructor for term rotl_imm.
16366
0
pub fn constructor_rotl_imm<C: Context>(
16367
0
    ctx: &mut C,
16368
0
    arg0: Type,
16369
0
    arg1: Value,
16370
0
    arg2: Imm64,
16371
0
) -> Value {
16372
0
    let v4 = InstructionData::BinaryImm64 {
16373
0
        opcode: Opcode::RotlImm,
16374
0
        arg: arg1,
16375
0
        imm: arg2,
16376
0
    };
16377
0
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);
16378
    // Rule at <OUT_DIR>/clif_opt.isle line 1389.
16379
0
    return v5;
16380
0
}
16381
16382
// Generated as internal constructor for term rotr_imm.
16383
0
pub fn constructor_rotr_imm<C: Context>(
16384
0
    ctx: &mut C,
16385
0
    arg0: Type,
16386
0
    arg1: Value,
16387
0
    arg2: Imm64,
16388
0
) -> Value {
16389
0
    let v4 = InstructionData::BinaryImm64 {
16390
0
        opcode: Opcode::RotrImm,
16391
0
        arg: arg1,
16392
0
        imm: arg2,
16393
0
    };
16394
0
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);
16395
    // Rule at <OUT_DIR>/clif_opt.isle line 1398.
16396
0
    return v5;
16397
0
}
16398
16399
// Generated as internal constructor for term ishl.
16400
175
pub fn constructor_ishl<C: Context>(
16401
175
    ctx: &mut C,
16402
175
    arg0: Type,
16403
175
    arg1: Value,
16404
175
    arg2: Value,
16405
175
) -> Value {
16406
175
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
16407
175
    let v5 = InstructionData::Binary {
16408
175
        opcode: Opcode::Ishl,
16409
175
        args: v4.clone(),
16410
175
    };
16411
175
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
16412
    // Rule at <OUT_DIR>/clif_opt.isle line 1407.
16413
175
    return v6;
16414
175
}
16415
16416
// Generated as internal constructor for term ushr.
16417
4.50k
pub fn constructor_ushr<C: Context>(
16418
4.50k
    ctx: &mut C,
16419
4.50k
    arg0: Type,
16420
4.50k
    arg1: Value,
16421
4.50k
    arg2: Value,
16422
4.50k
) -> Value {
16423
4.50k
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
16424
4.50k
    let v5 = InstructionData::Binary {
16425
4.50k
        opcode: Opcode::Ushr,
16426
4.50k
        args: v4.clone(),
16427
4.50k
    };
16428
4.50k
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
16429
    // Rule at <OUT_DIR>/clif_opt.isle line 1416.
16430
4.50k
    return v6;
16431
4.50k
}
16432
16433
// Generated as internal constructor for term sshr.
16434
501
pub fn constructor_sshr<C: Context>(
16435
501
    ctx: &mut C,
16436
501
    arg0: Type,
16437
501
    arg1: Value,
16438
501
    arg2: Value,
16439
501
) -> Value {
16440
501
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
16441
501
    let v5 = InstructionData::Binary {
16442
501
        opcode: Opcode::Sshr,
16443
501
        args: v4.clone(),
16444
501
    };
16445
501
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
16446
    // Rule at <OUT_DIR>/clif_opt.isle line 1425.
16447
501
    return v6;
16448
501
}
16449
16450
// Generated as internal constructor for term ishl_imm.
16451
0
pub fn constructor_ishl_imm<C: Context>(
16452
0
    ctx: &mut C,
16453
0
    arg0: Type,
16454
0
    arg1: Value,
16455
0
    arg2: Imm64,
16456
0
) -> Value {
16457
0
    let v4 = InstructionData::BinaryImm64 {
16458
0
        opcode: Opcode::IshlImm,
16459
0
        arg: arg1,
16460
0
        imm: arg2,
16461
0
    };
16462
0
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);
16463
    // Rule at <OUT_DIR>/clif_opt.isle line 1434.
16464
0
    return v5;
16465
0
}
16466
16467
// Generated as internal constructor for term ushr_imm.
16468
0
pub fn constructor_ushr_imm<C: Context>(
16469
0
    ctx: &mut C,
16470
0
    arg0: Type,
16471
0
    arg1: Value,
16472
0
    arg2: Imm64,
16473
0
) -> Value {
16474
0
    let v4 = InstructionData::BinaryImm64 {
16475
0
        opcode: Opcode::UshrImm,
16476
0
        arg: arg1,
16477
0
        imm: arg2,
16478
0
    };
16479
0
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);
16480
    // Rule at <OUT_DIR>/clif_opt.isle line 1443.
16481
0
    return v5;
16482
0
}
16483
16484
// Generated as internal constructor for term sshr_imm.
16485
0
pub fn constructor_sshr_imm<C: Context>(
16486
0
    ctx: &mut C,
16487
0
    arg0: Type,
16488
0
    arg1: Value,
16489
0
    arg2: Imm64,
16490
0
) -> Value {
16491
0
    let v4 = InstructionData::BinaryImm64 {
16492
0
        opcode: Opcode::SshrImm,
16493
0
        arg: arg1,
16494
0
        imm: arg2,
16495
0
    };
16496
0
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);
16497
    // Rule at <OUT_DIR>/clif_opt.isle line 1452.
16498
0
    return v5;
16499
0
}
16500
16501
// Generated as internal constructor for term bitrev.
16502
0
pub fn constructor_bitrev<C: Context>(
16503
0
    ctx: &mut C,
16504
0
    arg0: Type,
16505
0
    arg1: Value,
16506
0
) -> Value {
16507
0
    let v3 = InstructionData::Unary {
16508
0
        opcode: Opcode::Bitrev,
16509
0
        arg: arg1,
16510
0
    };
16511
0
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
16512
    // Rule at <OUT_DIR>/clif_opt.isle line 1461.
16513
0
    return v4;
16514
0
}
16515
16516
// Generated as internal constructor for term clz.
16517
0
pub fn constructor_clz<C: Context>(
16518
0
    ctx: &mut C,
16519
0
    arg0: Type,
16520
0
    arg1: Value,
16521
0
) -> Value {
16522
0
    let v3 = InstructionData::Unary {
16523
0
        opcode: Opcode::Clz,
16524
0
        arg: arg1,
16525
0
    };
16526
0
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
16527
    // Rule at <OUT_DIR>/clif_opt.isle line 1470.
16528
0
    return v4;
16529
0
}
16530
16531
// Generated as internal constructor for term cls.
16532
0
pub fn constructor_cls<C: Context>(
16533
0
    ctx: &mut C,
16534
0
    arg0: Type,
16535
0
    arg1: Value,
16536
0
) -> Value {
16537
0
    let v3 = InstructionData::Unary {
16538
0
        opcode: Opcode::Cls,
16539
0
        arg: arg1,
16540
0
    };
16541
0
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
16542
    // Rule at <OUT_DIR>/clif_opt.isle line 1479.
16543
0
    return v4;
16544
0
}
16545
16546
// Generated as internal constructor for term ctz.
16547
0
pub fn constructor_ctz<C: Context>(
16548
0
    ctx: &mut C,
16549
0
    arg0: Type,
16550
0
    arg1: Value,
16551
0
) -> Value {
16552
0
    let v3 = InstructionData::Unary {
16553
0
        opcode: Opcode::Ctz,
16554
0
        arg: arg1,
16555
0
    };
16556
0
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
16557
    // Rule at <OUT_DIR>/clif_opt.isle line 1488.
16558
0
    return v4;
16559
0
}
16560
16561
// Generated as internal constructor for term bswap.
16562
0
pub fn constructor_bswap<C: Context>(
16563
0
    ctx: &mut C,
16564
0
    arg0: Type,
16565
0
    arg1: Value,
16566
0
) -> Value {
16567
0
    let v3 = InstructionData::Unary {
16568
0
        opcode: Opcode::Bswap,
16569
0
        arg: arg1,
16570
0
    };
16571
0
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
16572
    // Rule at <OUT_DIR>/clif_opt.isle line 1497.
16573
0
    return v4;
16574
0
}
16575
16576
// Generated as internal constructor for term popcnt.
16577
0
pub fn constructor_popcnt<C: Context>(
16578
0
    ctx: &mut C,
16579
0
    arg0: Type,
16580
0
    arg1: Value,
16581
0
) -> Value {
16582
0
    let v3 = InstructionData::Unary {
16583
0
        opcode: Opcode::Popcnt,
16584
0
        arg: arg1,
16585
0
    };
16586
0
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
16587
    // Rule at <OUT_DIR>/clif_opt.isle line 1506.
16588
0
    return v4;
16589
0
}
16590
16591
// Generated as internal constructor for term fcmp.
16592
0
pub fn constructor_fcmp<C: Context>(
16593
0
    ctx: &mut C,
16594
0
    arg0: Type,
16595
0
    arg1: &FloatCC,
16596
0
    arg2: Value,
16597
0
    arg3: Value,
16598
0
) -> Value {
16599
0
    let v5 = &C::value_array_2_ctor(ctx, arg2, arg3);
16600
0
    let v6 = InstructionData::FloatCompare {
16601
0
        opcode: Opcode::Fcmp,
16602
0
        args: v5.clone(),
16603
0
        cond: arg1.clone(),
16604
0
    };
16605
0
    let v7 = C::make_inst_ctor(ctx, arg0, &v6);
16606
    // Rule at <OUT_DIR>/clif_opt.isle line 1515.
16607
0
    return v7;
16608
0
}
16609
16610
// Generated as internal constructor for term fadd.
16611
0
pub fn constructor_fadd<C: Context>(
16612
0
    ctx: &mut C,
16613
0
    arg0: Type,
16614
0
    arg1: Value,
16615
0
    arg2: Value,
16616
0
) -> Value {
16617
0
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
16618
0
    let v5 = InstructionData::Binary {
16619
0
        opcode: Opcode::Fadd,
16620
0
        args: v4.clone(),
16621
0
    };
16622
0
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
16623
    // Rule at <OUT_DIR>/clif_opt.isle line 1524.
16624
0
    return v6;
16625
0
}
16626
16627
// Generated as internal constructor for term fsub.
16628
0
pub fn constructor_fsub<C: Context>(
16629
0
    ctx: &mut C,
16630
0
    arg0: Type,
16631
0
    arg1: Value,
16632
0
    arg2: Value,
16633
0
) -> Value {
16634
0
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
16635
0
    let v5 = InstructionData::Binary {
16636
0
        opcode: Opcode::Fsub,
16637
0
        args: v4.clone(),
16638
0
    };
16639
0
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
16640
    // Rule at <OUT_DIR>/clif_opt.isle line 1533.
16641
0
    return v6;
16642
0
}
16643
16644
// Generated as internal constructor for term fmul.
16645
0
pub fn constructor_fmul<C: Context>(
16646
0
    ctx: &mut C,
16647
0
    arg0: Type,
16648
0
    arg1: Value,
16649
0
    arg2: Value,
16650
0
) -> Value {
16651
0
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
16652
0
    let v5 = InstructionData::Binary {
16653
0
        opcode: Opcode::Fmul,
16654
0
        args: v4.clone(),
16655
0
    };
16656
0
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
16657
    // Rule at <OUT_DIR>/clif_opt.isle line 1542.
16658
0
    return v6;
16659
0
}
16660
16661
// Generated as internal constructor for term fdiv.
16662
0
pub fn constructor_fdiv<C: Context>(
16663
0
    ctx: &mut C,
16664
0
    arg0: Type,
16665
0
    arg1: Value,
16666
0
    arg2: Value,
16667
0
) -> Value {
16668
0
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
16669
0
    let v5 = InstructionData::Binary {
16670
0
        opcode: Opcode::Fdiv,
16671
0
        args: v4.clone(),
16672
0
    };
16673
0
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
16674
    // Rule at <OUT_DIR>/clif_opt.isle line 1551.
16675
0
    return v6;
16676
0
}
16677
16678
// Generated as internal constructor for term sqrt.
16679
0
pub fn constructor_sqrt<C: Context>(
16680
0
    ctx: &mut C,
16681
0
    arg0: Type,
16682
0
    arg1: Value,
16683
0
) -> Value {
16684
0
    let v3 = InstructionData::Unary {
16685
0
        opcode: Opcode::Sqrt,
16686
0
        arg: arg1,
16687
0
    };
16688
0
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
16689
    // Rule at <OUT_DIR>/clif_opt.isle line 1560.
16690
0
    return v4;
16691
0
}
16692
16693
// Generated as internal constructor for term fma.
16694
0
pub fn constructor_fma<C: Context>(
16695
0
    ctx: &mut C,
16696
0
    arg0: Type,
16697
0
    arg1: Value,
16698
0
    arg2: Value,
16699
0
    arg3: Value,
16700
0
) -> Value {
16701
0
    let v5 = &C::value_array_3_ctor(ctx, arg1, arg2, arg3);
16702
0
    let v6 = InstructionData::Ternary {
16703
0
        opcode: Opcode::Fma,
16704
0
        args: v5.clone(),
16705
0
    };
16706
0
    let v7 = C::make_inst_ctor(ctx, arg0, &v6);
16707
    // Rule at <OUT_DIR>/clif_opt.isle line 1569.
16708
0
    return v7;
16709
0
}
16710
16711
// Generated as internal constructor for term fneg.
16712
0
pub fn constructor_fneg<C: Context>(
16713
0
    ctx: &mut C,
16714
0
    arg0: Type,
16715
0
    arg1: Value,
16716
0
) -> Value {
16717
0
    let v3 = InstructionData::Unary {
16718
0
        opcode: Opcode::Fneg,
16719
0
        arg: arg1,
16720
0
    };
16721
0
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
16722
    // Rule at <OUT_DIR>/clif_opt.isle line 1578.
16723
0
    return v4;
16724
0
}
16725
16726
// Generated as internal constructor for term fabs.
16727
0
pub fn constructor_fabs<C: Context>(
16728
0
    ctx: &mut C,
16729
0
    arg0: Type,
16730
0
    arg1: Value,
16731
0
) -> Value {
16732
0
    let v3 = InstructionData::Unary {
16733
0
        opcode: Opcode::Fabs,
16734
0
        arg: arg1,
16735
0
    };
16736
0
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
16737
    // Rule at <OUT_DIR>/clif_opt.isle line 1587.
16738
0
    return v4;
16739
0
}
16740
16741
// Generated as internal constructor for term fcopysign.
16742
0
pub fn constructor_fcopysign<C: Context>(
16743
0
    ctx: &mut C,
16744
0
    arg0: Type,
16745
0
    arg1: Value,
16746
0
    arg2: Value,
16747
0
) -> Value {
16748
0
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
16749
0
    let v5 = InstructionData::Binary {
16750
0
        opcode: Opcode::Fcopysign,
16751
0
        args: v4.clone(),
16752
0
    };
16753
0
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
16754
    // Rule at <OUT_DIR>/clif_opt.isle line 1596.
16755
0
    return v6;
16756
0
}
16757
16758
// Generated as internal constructor for term fmin.
16759
0
pub fn constructor_fmin<C: Context>(
16760
0
    ctx: &mut C,
16761
0
    arg0: Type,
16762
0
    arg1: Value,
16763
0
    arg2: Value,
16764
0
) -> Value {
16765
0
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
16766
0
    let v5 = InstructionData::Binary {
16767
0
        opcode: Opcode::Fmin,
16768
0
        args: v4.clone(),
16769
0
    };
16770
0
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
16771
    // Rule at <OUT_DIR>/clif_opt.isle line 1605.
16772
0
    return v6;
16773
0
}
16774
16775
// Generated as internal constructor for term fmax.
16776
0
pub fn constructor_fmax<C: Context>(
16777
0
    ctx: &mut C,
16778
0
    arg0: Type,
16779
0
    arg1: Value,
16780
0
    arg2: Value,
16781
0
) -> Value {
16782
0
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
16783
0
    let v5 = InstructionData::Binary {
16784
0
        opcode: Opcode::Fmax,
16785
0
        args: v4.clone(),
16786
0
    };
16787
0
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
16788
    // Rule at <OUT_DIR>/clif_opt.isle line 1614.
16789
0
    return v6;
16790
0
}
16791
16792
// Generated as internal constructor for term ceil.
16793
0
pub fn constructor_ceil<C: Context>(
16794
0
    ctx: &mut C,
16795
0
    arg0: Type,
16796
0
    arg1: Value,
16797
0
) -> Value {
16798
0
    let v3 = InstructionData::Unary {
16799
0
        opcode: Opcode::Ceil,
16800
0
        arg: arg1,
16801
0
    };
16802
0
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
16803
    // Rule at <OUT_DIR>/clif_opt.isle line 1623.
16804
0
    return v4;
16805
0
}
16806
16807
// Generated as internal constructor for term floor.
16808
0
pub fn constructor_floor<C: Context>(
16809
0
    ctx: &mut C,
16810
0
    arg0: Type,
16811
0
    arg1: Value,
16812
0
) -> Value {
16813
0
    let v3 = InstructionData::Unary {
16814
0
        opcode: Opcode::Floor,
16815
0
        arg: arg1,
16816
0
    };
16817
0
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
16818
    // Rule at <OUT_DIR>/clif_opt.isle line 1632.
16819
0
    return v4;
16820
0
}
16821
16822
// Generated as internal constructor for term trunc.
16823
0
pub fn constructor_trunc<C: Context>(
16824
0
    ctx: &mut C,
16825
0
    arg0: Type,
16826
0
    arg1: Value,
16827
0
) -> Value {
16828
0
    let v3 = InstructionData::Unary {
16829
0
        opcode: Opcode::Trunc,
16830
0
        arg: arg1,
16831
0
    };
16832
0
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
16833
    // Rule at <OUT_DIR>/clif_opt.isle line 1641.
16834
0
    return v4;
16835
0
}
16836
16837
// Generated as internal constructor for term nearest.
16838
0
pub fn constructor_nearest<C: Context>(
16839
0
    ctx: &mut C,
16840
0
    arg0: Type,
16841
0
    arg1: Value,
16842
0
) -> Value {
16843
0
    let v3 = InstructionData::Unary {
16844
0
        opcode: Opcode::Nearest,
16845
0
        arg: arg1,
16846
0
    };
16847
0
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
16848
    // Rule at <OUT_DIR>/clif_opt.isle line 1650.
16849
0
    return v4;
16850
0
}
16851
16852
// Generated as internal constructor for term bitcast.
16853
0
pub fn constructor_bitcast<C: Context>(
16854
0
    ctx: &mut C,
16855
0
    arg0: Type,
16856
0
    arg1: MemFlags,
16857
0
    arg2: Value,
16858
0
) -> Value {
16859
0
    let v4 = InstructionData::LoadNoOffset {
16860
0
        opcode: Opcode::Bitcast,
16861
0
        arg: arg2,
16862
0
        flags: arg1,
16863
0
    };
16864
0
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);
16865
    // Rule at <OUT_DIR>/clif_opt.isle line 1659.
16866
0
    return v5;
16867
0
}
16868
16869
// Generated as internal constructor for term scalar_to_vector.
16870
0
pub fn constructor_scalar_to_vector<C: Context>(
16871
0
    ctx: &mut C,
16872
0
    arg0: Type,
16873
0
    arg1: Value,
16874
0
) -> Value {
16875
0
    let v3 = InstructionData::Unary {
16876
0
        opcode: Opcode::ScalarToVector,
16877
0
        arg: arg1,
16878
0
    };
16879
0
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
16880
    // Rule at <OUT_DIR>/clif_opt.isle line 1668.
16881
0
    return v4;
16882
0
}
16883
16884
// Generated as internal constructor for term bmask.
16885
8
pub fn constructor_bmask<C: Context>(
16886
8
    ctx: &mut C,
16887
8
    arg0: Type,
16888
8
    arg1: Value,
16889
8
) -> Value {
16890
8
    let v3 = InstructionData::Unary {
16891
8
        opcode: Opcode::Bmask,
16892
8
        arg: arg1,
16893
8
    };
16894
8
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
16895
    // Rule at <OUT_DIR>/clif_opt.isle line 1677.
16896
8
    return v4;
16897
8
}
16898
16899
// Generated as internal constructor for term ireduce.
16900
7.53k
pub fn constructor_ireduce<C: Context>(
16901
7.53k
    ctx: &mut C,
16902
7.53k
    arg0: Type,
16903
7.53k
    arg1: Value,
16904
7.53k
) -> Value {
16905
7.53k
    let v3 = InstructionData::Unary {
16906
7.53k
        opcode: Opcode::Ireduce,
16907
7.53k
        arg: arg1,
16908
7.53k
    };
16909
7.53k
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
16910
    // Rule at <OUT_DIR>/clif_opt.isle line 1686.
16911
7.53k
    return v4;
16912
7.53k
}
16913
16914
// Generated as internal constructor for term snarrow.
16915
0
pub fn constructor_snarrow<C: Context>(
16916
0
    ctx: &mut C,
16917
0
    arg0: Type,
16918
0
    arg1: Value,
16919
0
    arg2: Value,
16920
0
) -> Value {
16921
0
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
16922
0
    let v5 = InstructionData::Binary {
16923
0
        opcode: Opcode::Snarrow,
16924
0
        args: v4.clone(),
16925
0
    };
16926
0
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
16927
    // Rule at <OUT_DIR>/clif_opt.isle line 1695.
16928
0
    return v6;
16929
0
}
16930
16931
// Generated as internal constructor for term unarrow.
16932
0
pub fn constructor_unarrow<C: Context>(
16933
0
    ctx: &mut C,
16934
0
    arg0: Type,
16935
0
    arg1: Value,
16936
0
    arg2: Value,
16937
0
) -> Value {
16938
0
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
16939
0
    let v5 = InstructionData::Binary {
16940
0
        opcode: Opcode::Unarrow,
16941
0
        args: v4.clone(),
16942
0
    };
16943
0
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
16944
    // Rule at <OUT_DIR>/clif_opt.isle line 1704.
16945
0
    return v6;
16946
0
}
16947
16948
// Generated as internal constructor for term uunarrow.
16949
0
pub fn constructor_uunarrow<C: Context>(
16950
0
    ctx: &mut C,
16951
0
    arg0: Type,
16952
0
    arg1: Value,
16953
0
    arg2: Value,
16954
0
) -> Value {
16955
0
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
16956
0
    let v5 = InstructionData::Binary {
16957
0
        opcode: Opcode::Uunarrow,
16958
0
        args: v4.clone(),
16959
0
    };
16960
0
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
16961
    // Rule at <OUT_DIR>/clif_opt.isle line 1713.
16962
0
    return v6;
16963
0
}
16964
16965
// Generated as internal constructor for term swiden_low.
16966
0
pub fn constructor_swiden_low<C: Context>(
16967
0
    ctx: &mut C,
16968
0
    arg0: Type,
16969
0
    arg1: Value,
16970
0
) -> Value {
16971
0
    let v3 = InstructionData::Unary {
16972
0
        opcode: Opcode::SwidenLow,
16973
0
        arg: arg1,
16974
0
    };
16975
0
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
16976
    // Rule at <OUT_DIR>/clif_opt.isle line 1722.
16977
0
    return v4;
16978
0
}
16979
16980
// Generated as internal constructor for term swiden_high.
16981
0
pub fn constructor_swiden_high<C: Context>(
16982
0
    ctx: &mut C,
16983
0
    arg0: Type,
16984
0
    arg1: Value,
16985
0
) -> Value {
16986
0
    let v3 = InstructionData::Unary {
16987
0
        opcode: Opcode::SwidenHigh,
16988
0
        arg: arg1,
16989
0
    };
16990
0
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
16991
    // Rule at <OUT_DIR>/clif_opt.isle line 1731.
16992
0
    return v4;
16993
0
}
16994
16995
// Generated as internal constructor for term uwiden_low.
16996
0
pub fn constructor_uwiden_low<C: Context>(
16997
0
    ctx: &mut C,
16998
0
    arg0: Type,
16999
0
    arg1: Value,
17000
0
) -> Value {
17001
0
    let v3 = InstructionData::Unary {
17002
0
        opcode: Opcode::UwidenLow,
17003
0
        arg: arg1,
17004
0
    };
17005
0
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
17006
    // Rule at <OUT_DIR>/clif_opt.isle line 1740.
17007
0
    return v4;
17008
0
}
17009
17010
// Generated as internal constructor for term uwiden_high.
17011
0
pub fn constructor_uwiden_high<C: Context>(
17012
0
    ctx: &mut C,
17013
0
    arg0: Type,
17014
0
    arg1: Value,
17015
0
) -> Value {
17016
0
    let v3 = InstructionData::Unary {
17017
0
        opcode: Opcode::UwidenHigh,
17018
0
        arg: arg1,
17019
0
    };
17020
0
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
17021
    // Rule at <OUT_DIR>/clif_opt.isle line 1749.
17022
0
    return v4;
17023
0
}
17024
17025
// Generated as internal constructor for term iadd_pairwise.
17026
0
pub fn constructor_iadd_pairwise<C: Context>(
17027
0
    ctx: &mut C,
17028
0
    arg0: Type,
17029
0
    arg1: Value,
17030
0
    arg2: Value,
17031
0
) -> Value {
17032
0
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
17033
0
    let v5 = InstructionData::Binary {
17034
0
        opcode: Opcode::IaddPairwise,
17035
0
        args: v4.clone(),
17036
0
    };
17037
0
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
17038
    // Rule at <OUT_DIR>/clif_opt.isle line 1758.
17039
0
    return v6;
17040
0
}
17041
17042
// Generated as internal constructor for term x86_pmaddubsw.
17043
0
pub fn constructor_x86_pmaddubsw<C: Context>(
17044
0
    ctx: &mut C,
17045
0
    arg0: Type,
17046
0
    arg1: Value,
17047
0
    arg2: Value,
17048
0
) -> Value {
17049
0
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
17050
0
    let v5 = InstructionData::Binary {
17051
0
        opcode: Opcode::X86Pmaddubsw,
17052
0
        args: v4.clone(),
17053
0
    };
17054
0
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
17055
    // Rule at <OUT_DIR>/clif_opt.isle line 1767.
17056
0
    return v6;
17057
0
}
17058
17059
// Generated as internal constructor for term uextend.
17060
12.8k
pub fn constructor_uextend<C: Context>(
17061
12.8k
    ctx: &mut C,
17062
12.8k
    arg0: Type,
17063
12.8k
    arg1: Value,
17064
12.8k
) -> Value {
17065
12.8k
    let v3 = InstructionData::Unary {
17066
12.8k
        opcode: Opcode::Uextend,
17067
12.8k
        arg: arg1,
17068
12.8k
    };
17069
12.8k
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
17070
    // Rule at <OUT_DIR>/clif_opt.isle line 1776.
17071
12.8k
    return v4;
17072
12.8k
}
17073
17074
// Generated as internal constructor for term sextend.
17075
524
pub fn constructor_sextend<C: Context>(
17076
524
    ctx: &mut C,
17077
524
    arg0: Type,
17078
524
    arg1: Value,
17079
524
) -> Value {
17080
524
    let v3 = InstructionData::Unary {
17081
524
        opcode: Opcode::Sextend,
17082
524
        arg: arg1,
17083
524
    };
17084
524
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
17085
    // Rule at <OUT_DIR>/clif_opt.isle line 1785.
17086
524
    return v4;
17087
524
}
17088
17089
// Generated as internal constructor for term fpromote.
17090
0
pub fn constructor_fpromote<C: Context>(
17091
0
    ctx: &mut C,
17092
0
    arg0: Type,
17093
0
    arg1: Value,
17094
0
) -> Value {
17095
0
    let v3 = InstructionData::Unary {
17096
0
        opcode: Opcode::Fpromote,
17097
0
        arg: arg1,
17098
0
    };
17099
0
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
17100
    // Rule at <OUT_DIR>/clif_opt.isle line 1794.
17101
0
    return v4;
17102
0
}
17103
17104
// Generated as internal constructor for term fdemote.
17105
0
pub fn constructor_fdemote<C: Context>(
17106
0
    ctx: &mut C,
17107
0
    arg0: Type,
17108
0
    arg1: Value,
17109
0
) -> Value {
17110
0
    let v3 = InstructionData::Unary {
17111
0
        opcode: Opcode::Fdemote,
17112
0
        arg: arg1,
17113
0
    };
17114
0
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
17115
    // Rule at <OUT_DIR>/clif_opt.isle line 1803.
17116
0
    return v4;
17117
0
}
17118
17119
// Generated as internal constructor for term fvdemote.
17120
0
pub fn constructor_fvdemote<C: Context>(
17121
0
    ctx: &mut C,
17122
0
    arg0: Type,
17123
0
    arg1: Value,
17124
0
) -> Value {
17125
0
    let v3 = InstructionData::Unary {
17126
0
        opcode: Opcode::Fvdemote,
17127
0
        arg: arg1,
17128
0
    };
17129
0
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
17130
    // Rule at <OUT_DIR>/clif_opt.isle line 1812.
17131
0
    return v4;
17132
0
}
17133
17134
// Generated as internal constructor for term fvpromote_low.
17135
0
pub fn constructor_fvpromote_low<C: Context>(
17136
0
    ctx: &mut C,
17137
0
    arg0: Type,
17138
0
    arg1: Value,
17139
0
) -> Value {
17140
0
    let v3 = InstructionData::Unary {
17141
0
        opcode: Opcode::FvpromoteLow,
17142
0
        arg: arg1,
17143
0
    };
17144
0
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
17145
    // Rule at <OUT_DIR>/clif_opt.isle line 1821.
17146
0
    return v4;
17147
0
}
17148
17149
// Generated as internal constructor for term fcvt_to_uint.
17150
0
pub fn constructor_fcvt_to_uint<C: Context>(
17151
0
    ctx: &mut C,
17152
0
    arg0: Value,
17153
0
) -> Inst {
17154
0
    let v2 = InstructionData::Unary {
17155
0
        opcode: Opcode::FcvtToUint,
17156
0
        arg: arg0,
17157
0
    };
17158
0
    let v3 = C::make_skeleton_inst_ctor(ctx, &v2);
17159
    // Rule at <OUT_DIR>/clif_opt.isle line 1830.
17160
0
    return v3;
17161
0
}
17162
17163
// Generated as internal constructor for term fcvt_to_sint.
17164
0
pub fn constructor_fcvt_to_sint<C: Context>(
17165
0
    ctx: &mut C,
17166
0
    arg0: Value,
17167
0
) -> Inst {
17168
0
    let v2 = InstructionData::Unary {
17169
0
        opcode: Opcode::FcvtToSint,
17170
0
        arg: arg0,
17171
0
    };
17172
0
    let v3 = C::make_skeleton_inst_ctor(ctx, &v2);
17173
    // Rule at <OUT_DIR>/clif_opt.isle line 1839.
17174
0
    return v3;
17175
0
}
17176
17177
// Generated as internal constructor for term fcvt_to_uint_sat.
17178
0
pub fn constructor_fcvt_to_uint_sat<C: Context>(
17179
0
    ctx: &mut C,
17180
0
    arg0: Type,
17181
0
    arg1: Value,
17182
0
) -> Value {
17183
0
    let v3 = InstructionData::Unary {
17184
0
        opcode: Opcode::FcvtToUintSat,
17185
0
        arg: arg1,
17186
0
    };
17187
0
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
17188
    // Rule at <OUT_DIR>/clif_opt.isle line 1848.
17189
0
    return v4;
17190
0
}
17191
17192
// Generated as internal constructor for term fcvt_to_sint_sat.
17193
0
pub fn constructor_fcvt_to_sint_sat<C: Context>(
17194
0
    ctx: &mut C,
17195
0
    arg0: Type,
17196
0
    arg1: Value,
17197
0
) -> Value {
17198
0
    let v3 = InstructionData::Unary {
17199
0
        opcode: Opcode::FcvtToSintSat,
17200
0
        arg: arg1,
17201
0
    };
17202
0
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
17203
    // Rule at <OUT_DIR>/clif_opt.isle line 1857.
17204
0
    return v4;
17205
0
}
17206
17207
// Generated as internal constructor for term x86_cvtt2dq.
17208
0
pub fn constructor_x86_cvtt2dq<C: Context>(
17209
0
    ctx: &mut C,
17210
0
    arg0: Type,
17211
0
    arg1: Value,
17212
0
) -> Value {
17213
0
    let v3 = InstructionData::Unary {
17214
0
        opcode: Opcode::X86Cvtt2dq,
17215
0
        arg: arg1,
17216
0
    };
17217
0
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
17218
    // Rule at <OUT_DIR>/clif_opt.isle line 1866.
17219
0
    return v4;
17220
0
}
17221
17222
// Generated as internal constructor for term fcvt_from_uint.
17223
0
pub fn constructor_fcvt_from_uint<C: Context>(
17224
0
    ctx: &mut C,
17225
0
    arg0: Type,
17226
0
    arg1: Value,
17227
0
) -> Value {
17228
0
    let v3 = InstructionData::Unary {
17229
0
        opcode: Opcode::FcvtFromUint,
17230
0
        arg: arg1,
17231
0
    };
17232
0
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
17233
    // Rule at <OUT_DIR>/clif_opt.isle line 1875.
17234
0
    return v4;
17235
0
}
17236
17237
// Generated as internal constructor for term fcvt_from_sint.
17238
0
pub fn constructor_fcvt_from_sint<C: Context>(
17239
0
    ctx: &mut C,
17240
0
    arg0: Type,
17241
0
    arg1: Value,
17242
0
) -> Value {
17243
0
    let v3 = InstructionData::Unary {
17244
0
        opcode: Opcode::FcvtFromSint,
17245
0
        arg: arg1,
17246
0
    };
17247
0
    let v4 = C::make_inst_ctor(ctx, arg0, &v3);
17248
    // Rule at <OUT_DIR>/clif_opt.isle line 1884.
17249
0
    return v4;
17250
0
}
17251
17252
// Generated as internal constructor for term isplit.
17253
0
pub fn constructor_isplit<C: Context>(
17254
0
    ctx: &mut C,
17255
0
    arg0: Value,
17256
0
) -> Inst {
17257
0
    let v2 = InstructionData::Unary {
17258
0
        opcode: Opcode::Isplit,
17259
0
        arg: arg0,
17260
0
    };
17261
0
    let v3 = C::make_skeleton_inst_ctor(ctx, &v2);
17262
    // Rule at <OUT_DIR>/clif_opt.isle line 1893.
17263
0
    return v3;
17264
0
}
17265
17266
// Generated as internal constructor for term iconcat.
17267
3.82k
pub fn constructor_iconcat<C: Context>(
17268
3.82k
    ctx: &mut C,
17269
3.82k
    arg0: Type,
17270
3.82k
    arg1: Value,
17271
3.82k
    arg2: Value,
17272
3.82k
) -> Value {
17273
3.82k
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
17274
3.82k
    let v5 = InstructionData::Binary {
17275
3.82k
        opcode: Opcode::Iconcat,
17276
3.82k
        args: v4.clone(),
17277
3.82k
    };
17278
3.82k
    let v6 = C::make_inst_ctor(ctx, arg0, &v5);
17279
    // Rule at <OUT_DIR>/clif_opt.isle line 1902.
17280
3.82k
    return v6;
17281
3.82k
}
17282
17283
// Generated as internal constructor for term atomic_rmw.
17284
0
pub fn constructor_atomic_rmw<C: Context>(
17285
0
    ctx: &mut C,
17286
0
    arg0: MemFlags,
17287
0
    arg1: &AtomicRmwOp,
17288
0
    arg2: Value,
17289
0
    arg3: Value,
17290
0
) -> Inst {
17291
0
    let v5 = &C::value_array_2_ctor(ctx, arg2, arg3);
17292
0
    let v6 = InstructionData::AtomicRmw {
17293
0
        opcode: Opcode::AtomicRmw,
17294
0
        args: v5.clone(),
17295
0
        flags: arg0,
17296
0
        op: arg1.clone(),
17297
0
    };
17298
0
    let v7 = C::make_skeleton_inst_ctor(ctx, &v6);
17299
    // Rule at <OUT_DIR>/clif_opt.isle line 1911.
17300
0
    return v7;
17301
0
}
17302
17303
// Generated as internal constructor for term atomic_cas.
17304
0
pub fn constructor_atomic_cas<C: Context>(
17305
0
    ctx: &mut C,
17306
0
    arg0: MemFlags,
17307
0
    arg1: Value,
17308
0
    arg2: Value,
17309
0
    arg3: Value,
17310
0
) -> Inst {
17311
0
    let v5 = &C::value_array_3_ctor(ctx, arg1, arg2, arg3);
17312
0
    let v6 = InstructionData::AtomicCas {
17313
0
        opcode: Opcode::AtomicCas,
17314
0
        args: v5.clone(),
17315
0
        flags: arg0,
17316
0
    };
17317
0
    let v7 = C::make_skeleton_inst_ctor(ctx, &v6);
17318
    // Rule at <OUT_DIR>/clif_opt.isle line 1920.
17319
0
    return v7;
17320
0
}
17321
17322
// Generated as internal constructor for term atomic_load.
17323
0
pub fn constructor_atomic_load<C: Context>(
17324
0
    ctx: &mut C,
17325
0
    arg0: MemFlags,
17326
0
    arg1: Value,
17327
0
) -> Inst {
17328
0
    let v3 = InstructionData::LoadNoOffset {
17329
0
        opcode: Opcode::AtomicLoad,
17330
0
        arg: arg1,
17331
0
        flags: arg0,
17332
0
    };
17333
0
    let v4 = C::make_skeleton_inst_ctor(ctx, &v3);
17334
    // Rule at <OUT_DIR>/clif_opt.isle line 1929.
17335
0
    return v4;
17336
0
}
17337
17338
// Generated as internal constructor for term atomic_store.
17339
0
pub fn constructor_atomic_store<C: Context>(
17340
0
    ctx: &mut C,
17341
0
    arg0: MemFlags,
17342
0
    arg1: Value,
17343
0
    arg2: Value,
17344
0
) -> Inst {
17345
0
    let v4 = &C::value_array_2_ctor(ctx, arg1, arg2);
17346
0
    let v5 = InstructionData::StoreNoOffset {
17347
0
        opcode: Opcode::AtomicStore,
17348
0
        args: v4.clone(),
17349
0
        flags: arg0,
17350
0
    };
17351
0
    let v6 = C::make_skeleton_inst_ctor(ctx, &v5);
17352
    // Rule at <OUT_DIR>/clif_opt.isle line 1938.
17353
0
    return v6;
17354
0
}
17355
17356
// Generated as internal constructor for term fence.
17357
0
pub fn constructor_fence<C: Context>(
17358
0
    ctx: &mut C,
17359
0
) -> Inst {
17360
0
    let v1 = InstructionData::NullAry {
17361
0
        opcode: Opcode::Fence,
17362
0
    };
17363
0
    let v2 = C::make_skeleton_inst_ctor(ctx, &v1);
17364
    // Rule at <OUT_DIR>/clif_opt.isle line 1947.
17365
0
    return v2;
17366
0
}
17367
17368
// Generated as internal constructor for term extract_vector.
17369
0
pub fn constructor_extract_vector<C: Context>(
17370
0
    ctx: &mut C,
17371
0
    arg0: Type,
17372
0
    arg1: Value,
17373
0
    arg2: Uimm8,
17374
0
) -> Value {
17375
0
    let v4 = InstructionData::BinaryImm8 {
17376
0
        opcode: Opcode::ExtractVector,
17377
0
        arg: arg1,
17378
0
        imm: arg2,
17379
0
    };
17380
0
    let v5 = C::make_inst_ctor(ctx, arg0, &v4);
17381
    // Rule at <OUT_DIR>/clif_opt.isle line 1956.
17382
0
    return v5;
17383
0
}